@lovrozagar/honey 0.6.8 → 0.7.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 { existsSync, readFileSync } from "node:fs"
+import { dirname, resolve, sep } from "node:path"
+import { createModuleLoader, honeyConfigOf, type ModuleLoader } from "./codegen-load.ts"
 import {
 	generateManifest,
 	generateOpenApi,
@@ -14,9 +14,13 @@ import {
 import type { OpenApiRouteInfo, OpenApiSanitizeOptions, OpenApiSpecInput } from "./codegen.ts"
 import type { Honey } from "./index.ts"
 import type { InvalidateCheckConfig } from "./invalidate-check.ts"
-import { overlaySchemas } from "./tree.ts"
+import { detectFeaturesInSource, featurePrelude, importsFeatureEntry } from "./feature-detect.ts"
+import { runCli } from "./gen-process.ts"
+import { writeGenFile, writeGenJsonFile, writeGenYamlFile, writeOutputDir } from "./gen-write.ts"
+import { WATCH_IGNORE_RE, compileGlobs } from "./glob.ts"
+import { overlaySchemas, type RouteTree } from "./tree.ts"
 import type { ExtractedChainTypes } from "./type-extractor.ts"
-import { toYaml, yamlSiblingPath } from "./yaml.ts"
+import { openApiOutputPaths, toYaml } from "./yaml.ts"
 
 export type { InvalidateCheckConfig, InvalidateCheckLevel } from "./invalidate-check.ts"
 
@@ -281,86 +285,69 @@ export function resolveHoneyConfig(raw: HoneyVitePluginConfig): ResolvedHoneyCon
 	}
 }
 
-/* ---- Config stash for CLI ---- */
+/* ---- Config stash ---- */
 
 let _lastConfig: HoneyVitePluginConfig | undefined
 
+/**
+ * Config of the most recent `honey()` call in this module instance.
+ * @deprecated Read the config off the plugin object (`plugin.api.honeyConfig`); this is a single
+ * global and does not survive a second module instance.
+ */
 export function getLastHoneyConfig(): HoneyVitePluginConfig | undefined {
 	return _lastConfig
 }
 
-/* ---- writeGenFile / writeGenJsonFile ---- */
+/* ---- Outputs ---- */
 
-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 TS_SDK_FILES = [
+	"sdk.types.gen.ts",
+	"sdk.map.gen.ts",
+	"sdk.client.gen.ts",
+	"sdk.index.gen.ts",
+	"sdk.runtime.gen.ts",
+]
 
-	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
+/** Every file and directory a generation writes, as absolute paths. Watchers must ignore these. */
+export function generatedOutputs(config: ResolvedHoneyConfig, root: string): { dirs: string[]; files: string[] } {
+	const cg = config.codegen
+	const files: string[] = []
+	const dirs: string[] = []
+	if (cg.tree) files.push(resolve(root, cg.tree))
+	if (cg.types) files.push(resolve(root, cg.types.path))
+	if (cg.manifest) files.push(resolve(root, cg.manifest))
+	for (const entry of cg.openApi || []) {
+		const out = openApiOutputPaths(resolve(root, entry.path))
+		if (out.json) files.push(out.json)
+		files.push(out.yaml)
 	}
-
-	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}`
-
-	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
-		} catch {
-			/* invalid JSON — proceed to write */
+	if (cg.sdk) {
+		const ports = cg.sdk.ports
+		if (ports.typescript) {
+			const outDir = resolve(root, ports.typescript.outDir)
+			files.push(...TS_SDK_FILES.map((name) => resolve(outDir, name)))
 		}
+		if (ports.python) dirs.push(resolve(root, ports.python.outDir))
+		if (ports.go) dirs.push(resolve(root, ports.go.outDir))
+		if (ports.rust) dirs.push(resolve(root, ports.rust.outDir))
 	}
-
-	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
+	if (cg.cli) dirs.push(resolve(root, cg.cli.out))
+	return { dirs, files }
 }
 
-function writeGenYamlFile(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 output = { _generated: marker, ...(data as Record<string, unknown>) }
-	const yaml = toYaml(output)
-
-	if (existsSync(filePath)) {
-		const existing = readFileSync(filePath, "utf-8")
-		if (existing.includes(marker)) return false
-	}
-
-	mkdirSync(dirname(filePath), { recursive: true })
-	writeFileSync(filePath, yaml, "utf-8")
-	return true
+export function isGeneratedOutput(file: string, outputs: { dirs: string[]; files: string[] }): boolean {
+	const abs = resolve(file)
+	if (outputs.files.includes(abs)) return true
+	return outputs.dirs.some((dir) => abs === dir || abs.startsWith(dir + sep))
 }
 
 /* ---- Loaders ---- */
 
 type HoneyApp = Honey<unknown, unknown, unknown, unknown, unknown, string, string>
-type TreeResult = { root: import("./tree.ts").TreeNode }
+type TreeResult = RouteTree
 
-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>
+async function loadAppOrTree(load: ModuleLoader, entryPath: string): Promise<unknown> {
+	const mod = await load(entryPath)
 
 	/* prefer named exports, then unwrap interop default */
 	if (mod.app && isHoneyApp(mod.app)) return mod.app
@@ -389,21 +376,60 @@ function isRouteTree(val: unknown): val is TreeResult {
 
 /* ---- Generation ---- */
 
-export async function generateAndWrite(config: ResolvedHoneyConfig, root: string): Promise<void> {
+/**
+ * The tree a `codegen.mergeTree` gateway serves: the merged downstream tree plus the routes
+ * the gateway app registers itself. Its root wildcard stays out — the downstream leaves
+ * delegate to it. Without a configured app the merged tree is served as is.
+ */
+async function gatewayTree(load: ModuleLoader, source: RouteTree, appPath: string | undefined): Promise<RouteTree> {
+	if (appPath === undefined) return source
+	const exported = await loadAppOrTree(load, appPath)
+	if (!isHoneyApp(exported)) throw new Error(`Expected Honey app default export in ${appPath}`)
+	return exported._gatewayTree(source)
+}
+
+export type GenerateOptions = {
+	/**
+	 * Loads the app, merge tree and type sources. Defaults to a fresh jiti loader per call. Modules
+	 * imported transitively may still come from the runtime's cache under Bun — run generation in
+	 * its own process (`honey generate`) when that matters.
+	 */
+	load?: ModuleLoader
+}
+
+export async function generateAndWrite(
+	config: ResolvedHoneyConfig,
+	root: string,
+	options: GenerateOptions = {},
+): Promise<void> {
 	await prepareCodegen()
 	const cg = config.codegen
+	let load = options.load ?? (await createModuleLoader({ fresh: true, from: resolve(root, "index.ts") }))
 
 	/* phase 1: route tree — from mergeTree source or app */
 	let mergeSource: TreeResult | undefined
 	if (cg.tree && (cg.mergeTree || config.app)) {
 		const treeSrc = resolve(root, cg.mergeTree ?? config.app ?? "")
-		const exported = await loadDefaultWithJiti(treeSrc)
+		const exported = await loadAppOrTree(load, treeSrc)
 
 		let treeCode: string
 		if (isHoneyApp(exported)) {
 			treeCode = generateRouteTreeFromApp(exported)
 		} else if (isRouteTree(exported)) {
-			treeCode = generateRouteTreeFromRouteTree(exported)
+			const appPath = cg.mergeTree && config.app ? resolve(root, config.app) : undefined
+			const treePath = resolve(root, cg.tree)
+			let tree: RouteTree
+			try {
+				tree = await gatewayTree(load, exported, appPath)
+			} catch (err) {
+				/* first run: the gateway app imports the tree this pass writes. Write the merged
+				   downstream tree, then load the app again over it to add its own routes. */
+				if (appPath === undefined || existsSync(treePath)) throw err
+				writeGenFile(treePath, generateRouteTreeFromRouteTree(exported), "honey")
+				load = await createModuleLoader({ fresh: true, from: resolve(root, "index.ts") })
+				tree = await gatewayTree(load, exported, appPath)
+			}
+			treeCode = generateRouteTreeFromRouteTree(tree)
 			mergeSource = exported
 		} else {
 			throw new Error(`Expected Honey app or RouteTree default export in ${treeSrc}`)
@@ -411,7 +437,7 @@ export async function generateAndWrite(config: ResolvedHoneyConfig, root: string
 
 		writeGenFile(resolve(root, cg.tree), treeCode, "honey")
 	} else if (cg.mergeTree && cg.openApi) {
-		const exported = await loadDefaultWithJiti(resolve(root, cg.mergeTree))
+		const exported = await loadAppOrTree(load, resolve(root, cg.mergeTree))
 		if (isRouteTree(exported)) mergeSource = exported
 	}
 
@@ -426,13 +452,14 @@ export async function generateAndWrite(config: ResolvedHoneyConfig, root: string
 			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)
+		/* the loader evaluates each file once, so the tree pass above did not cost a second load */
+		const appExported = await loadAppOrTree(load, appPath)
 		if (!isHoneyApp(appExported)) {
 			throw new Error(`Expected Honey app default export in ${appPath}`)
 		}
 		app = appExported
 		/* the app serves the intern tree (no schemas); document merged routes from their source */
-		if (mergeSource) overlaySchemas(app.toRouteTree().root, mergeSource.root)
+		if (mergeSource) overlaySchemas(app, mergeSource)
 	}
 
 	/* manifest */
@@ -461,9 +488,9 @@ export async function generateAndWrite(config: ResolvedHoneyConfig, root: string
 			if (entry.sanitize) {
 				spec = sanitizeOpenApiSpec(spec, entry.sanitize)
 			}
-			const jsonPath = resolve(root, entry.path)
-			writeGenJsonFile(jsonPath, spec, "honey")
-			writeGenYamlFile(yamlSiblingPath(jsonPath), spec, "honey")
+			const out = openApiOutputPaths(resolve(root, entry.path))
+			if (out.json) writeGenJsonFile(out.json, spec, "honey")
+			writeGenYamlFile(out.yaml, spec, "honey")
 		}
 	}
 
@@ -480,20 +507,13 @@ export async function generateAndWrite(config: ResolvedHoneyConfig, root: string
 		})
 
 		/* prefer appBase (middleware-only, simpler type) over app (with routes) */
-		let extracted: ExtractedChainTypes
-		try {
-			extracted = await extractChainTypes({
-				entryPath: appPath,
-				exportName: "appBase",
-				outputDir: typesDir,
-			})
-		} catch {
-			extracted = await extractChainTypes({
-				entryPath: appPath,
-				exportName: "app",
-				outputDir: typesDir,
-			})
-		}
+		const appModule = await load(appPath)
+		const exportName = "appBase" in appModule ? "appBase" : "app"
+		const extracted: ExtractedChainTypes = await extractChainTypes({
+			entryPath: appPath,
+			exportName,
+			outputDir: typesDir,
+		})
 
 		if (!app) throw new Error("Type generation requires a configured app")
 		const typesCode = generateTypes(app, {
@@ -507,9 +527,22 @@ export async function generateAndWrite(config: ResolvedHoneyConfig, root: string
 		writeGenFile(typesPath, typesCode, "honey")
 	}
 
+	/* The SDK and Go CLI share one unfiltered document. With openApi outputs the invalidate check
+	 * already ran on the first of them, so it is not reported again; without, it runs here once. */
+	let unfiltered: Promise<OpenApiSpecInput> | undefined
+	const unfilteredSpec = (what: string): Promise<OpenApiSpecInput> => {
+		if (!app) throw new Error(`${what} generation requires a configured app`)
+		const primaryOA = cg.openApi && cg.openApi.length > 0 ? cg.openApi[0] : null
+		unfiltered ??= generateOpenApi(app, {
+			info: primaryOA ? { title: primaryOA.title, version: primaryOA.version } : { title: "API", version: "1.0.0" },
+			invalidate: primaryOA ? "off" : cg.invalidate,
+		})
+		return unfiltered
+	}
+
 	/* sdk */
 	if (cg.sdk) {
-		const { generateOpenApi: genOA, generateSDK: genSDK, mergeSpecs } = await import("./codegen.ts")
+		const { generateSDK: genSDK, mergeSpecs } = await import("./codegen.ts")
 
 		let spec: OpenApiSpecInput
 		if (cg.sdk.specs && cg.sdk.specs.length > 0) {
@@ -519,12 +552,7 @@ export async function generateAndWrite(config: ResolvedHoneyConfig, root: string
 			})
 			spec = mergeSpecs(...specs)
 		} else {
-			if (!app) throw new Error("SDK generation requires a configured app or specs")
-			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 })
+			spec = await unfilteredSpec("SDK")
 		}
 
 		const ports = cg.sdk.ports
@@ -544,34 +572,19 @@ export async function generateAndWrite(config: ResolvedHoneyConfig, root: string
 		if (ports.python) {
 			const { generatePythonSDK } = await import("./codegen-python.ts")
 			const { files } = generatePythonSDK(spec, { name: cg.sdk.name })
-			const outDir = resolve(root, ports.python.outDir)
-			for (const [filename, content] of Object.entries(files)) {
-				const absPath = resolve(outDir, filename)
-				mkdirSync(dirname(absPath), { recursive: true })
-				writeFileSync(absPath, content, "utf-8")
-			}
+			writeOutputDir(resolve(root, ports.python.outDir), files)
 		}
 
 		if (ports.go) {
 			const { generateGoSDK } = await import("./codegen-go.ts")
 			const { files } = generateGoSDK(spec, { modulePath: ports.go.modulePath })
-			const outDir = resolve(root, ports.go.outDir)
-			for (const [filename, content] of Object.entries(files)) {
-				const absPath = resolve(outDir, filename)
-				mkdirSync(dirname(absPath), { recursive: true })
-				writeFileSync(absPath, content, "utf-8")
-			}
+			writeOutputDir(resolve(root, ports.go.outDir), files)
 		}
 
 		if (ports.rust) {
 			const { generateRustSDK } = await import("./codegen-rust.ts")
 			const { files } = generateRustSDK(spec, { crateName: ports.rust.crateName })
-			const outDir = resolve(root, ports.rust.outDir)
-			for (const [relPath, content] of Object.entries(files)) {
-				const absPath = resolve(outDir, relPath)
-				mkdirSync(dirname(absPath), { recursive: true })
-				writeFileSync(absPath, content, "utf-8")
-			}
+			writeOutputDir(resolve(root, ports.rust.outDir), files)
 		}
 	}
 
@@ -579,10 +592,7 @@ export async function generateAndWrite(config: ResolvedHoneyConfig, root: string
 	if (cg.cli) {
 		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" }
-		if (!app) throw new Error("CLI generation requires a configured app")
-		const spec = await generateOpenApi(app, { info })
+		const spec = await unfilteredSpec("CLI")
 
 		const { files } = generateGoCLI(spec, {
 			binaryName: cg.cli.binaryName,
@@ -592,13 +602,7 @@ export async function generateAndWrite(config: ResolvedHoneyConfig, root: string
 			modulePath: cg.cli.modulePath,
 			sdkModulePath: cg.cli.sdkModulePath,
 		})
-
-		const outDir = resolve(root, cg.cli.out)
-		for (const [relPath, content] of Object.entries(files)) {
-			const absPath = resolve(outDir, relPath)
-			mkdirSync(dirname(absPath), { recursive: true })
-			writeFileSync(absPath, content, "utf-8")
-		}
+		writeOutputDir(resolve(root, cg.cli.out), files)
 	}
 }
 
@@ -611,67 +615,141 @@ 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
+type ModuleGraphLike = { getModuleById(id: string): unknown }
+
+type PluginThis = {
+	environment?: { config?: { consumer?: string }; moduleGraph?: ModuleGraphLike }
+}
+
+type ResolvedViteConfigLike = {
+	command?: "build" | "serve"
+	configFile?: string
+	mode?: string
+	plugins?: readonly unknown[]
+	root: string
+}
+
+type HotUpdateContext = {
+	file: string
+	modules: unknown[]
+	server: { moduleGraph: ModuleGraphLike }
+	timestamp?: number
+}
+
+/* the route tree codegen emits TypeScript; a virtual module must be JavaScript in dev */
+async function toJavaScript(code: string): Promise<{ code: string; moduleType: string }> {
+	try {
+		const vite = (await import("vite")) as {
+			transformWithOxc?: (code: string, file: string, options: Record<string, unknown>) => Promise<{ code: string }>
+		}
+		if (vite.transformWithOxc) {
+			const out = await vite.transformWithOxc(code, "routes.gen.ts", { lang: "ts", sourcemap: false })
+			return { code: out.code, moduleType: "js" }
+		}
+	} catch {
+		/* no Vite 8 transform available — let the bundler strip types */
 	}
-	return false
+	return { code, moduleType: "ts" }
 }
 
 export function honey(config: HoneyVitePluginConfig) {
 	_lastConfig = config
 
 	const resolved = resolveHoneyConfig(config)
+	const watchPatterns = config.watch ?? []
+	const matchesWatch = compileGlobs(watchPatterns)
 
 	let root = ""
+	let configFile: string | undefined
+	let pluginIndex = -1
+	let command: "build" | "serve" = "build"
+	let mode = "production"
+	let outputs: { dirs: string[]; files: string[] } = { dirs: [], files: [] }
+
+	/* one generation at a time; any request during a run schedules exactly one more */
+	let running: Promise<void> | undefined
+	let rerun: Promise<void> | undefined
+	let starting: Promise<void> | undefined
+	const savesSeen = new Map<string, Promise<void>>()
+
+	async function generateOnce(): Promise<void> {
+		if (configFile && pluginIndex >= 0) {
+			/* a child process: fresh module graph, and the app's side effects die with it */
+			await runCli(["generate", "--config", configFile, "--plugin", String(pluginIndex)], {
+				cwd: root,
+				env: { HONEY_VITE_COMMAND: command, HONEY_VITE_MODE: mode },
+			})
+			return
+		}
+		await generateAndWrite(resolved, root)
+	}
 
-	const plugin: {
-		buildStart(): Promise<void>
-		configResolved(cfg: { root: string }): void
-		hotUpdate(ctx: {
-			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
-	} = {
+	function regenerate(): Promise<void> {
+		if (!running) {
+			running = generateOnce().finally(() => {
+				running = undefined
+			})
+			return running
+		}
+		if (!rerun) {
+			rerun = running
+				.catch(() => undefined)
+				.then(() => {
+					rerun = undefined
+					return regenerate()
+				})
+		}
+		return rerun
+	}
+
+	const plugin = {
+		/** Read by `honey generate` to find this plugin's config in a loaded Vite config. */
+		api: { honeyConfig: config },
+
+		/* Vite calls this once per environment, back to back: the second joins the running
+		 * generation instead of queueing another. A later buildStart (a watch rebuild) runs anew. */
 		async buildStart() {
-			await generateAndWrite(resolved, root)
+			starting ??= regenerate().finally(() => {
+				starting = undefined
+			})
+			await starting
 		},
 
-		configResolved(cfg: { root: string }) {
+		configResolved(cfg: ResolvedViteConfigLike) {
 			root = cfg.root
+			configFile = cfg.configFile
+			command = cfg.command ?? "build"
+			mode = cfg.mode ?? (command === "serve" ? "development" : "production")
+			outputs = generatedOutputs(resolved, root)
+			const honeyPlugins = (cfg.plugins ?? []).filter((p) => honeyConfigOf(p) !== undefined)
+			pluginIndex = honeyPlugins.findIndex((p) => p === plugin || honeyConfigOf(p) === config)
 		},
 
-		async hotUpdate(ctx: {
-			file: string
-			modules: unknown[]
-			server: {
-				moduleGraph: { getModuleById(id: string): unknown }
-				reloadModule(mod: unknown): void
+		/**
+		 * Regenerates when a watched file changes, then lets Vite's normal HMR proceed, adding the
+		 * virtual route tree to the update. Vite calls this once per environment; the generation
+		 * runs once per save.
+		 */
+		async hotUpdate(this: PluginThis | void, ctx: HotUpdateContext): Promise<unknown[] | undefined> {
+			if (watchPatterns.length === 0) return undefined
+			if (WATCH_IGNORE_RE.test(ctx.file) || isGeneratedOutput(ctx.file, outputs)) return undefined
+			if (!matchesWatch(ctx.file, root)) return undefined
+
+			const key = `${ctx.file}\0${ctx.timestamp ?? Date.now()}`
+			let run = savesSeen.get(key)
+			if (!run) {
+				run = regenerate().catch((err: unknown) => {
+					console.error("honey: generation failed", err)
+				})
+				savesSeen.set(key, run)
+				if (savesSeen.size > 64) savesSeen.delete(savesSeen.keys().next().value as string)
 			}
-		}) {
-			const patterns = config.watch
-			if (!patterns || patterns.length === 0) return
-			if (!matchesGlob(ctx.file, patterns)) return
-
-			await generateAndWrite(resolved, root)
+			await run
 
-			const mod = ctx.server.moduleGraph.getModuleById(RESOLVED_ROUTES)
-			if (mod) {
-				ctx.server.reloadModule(mod)
-			}
-			return []
+			const graph = (this && this.environment?.moduleGraph) || ctx.server.moduleGraph
+			const routes = graph.getModuleById(RESOLVED_ROUTES)
+			if (!routes || ctx.modules.includes(routes)) return undefined
+			return [...ctx.modules, routes]
 		},
 
 		async load(id: string): Promise<{ code: string; moduleType: string } | undefined> {
@@ -682,21 +760,23 @@ export function honey(config: HoneyVitePluginConfig) {
 				const treeSrc = resolved.codegen.mergeTree
 					? resolve(root, resolved.codegen.mergeTree)
 					: resolve(root, config.app ?? "")
-				const exported = await loadDefaultWithJiti(treeSrc)
+				const load = await createModuleLoader({ fresh: true, from: treeSrc })
+				const exported = await loadAppOrTree(load, treeSrc)
 				let code: string
 				if (isHoneyApp(exported)) {
 					code = generateRouteTreeFromApp(exported)
 				} else if (isRouteTree(exported)) {
-					code = generateRouteTreeFromRouteTree(exported)
+					const appPath = resolved.codegen.mergeTree && config.app ? resolve(root, config.app) : undefined
+					code = generateRouteTreeFromRouteTree(await gatewayTree(load, exported, appPath))
 				} else {
 					throw new Error(`Expected Honey app or RouteTree in ${treeSrc}`)
 				}
-				return { code, moduleType: "js" }
+				return toJavaScript(code)
 			}
 			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 exported = await loadAppOrTree(await createModuleLoader({ fresh: true, from: appPath }), appPath)
 				if (isHoneyApp(exported)) {
 					const manifest = generateManifest(exported)
 					return {
@@ -706,10 +786,10 @@ export function honey(config: HoneyVitePluginConfig) {
 				}
 			}
 			if (id === RESOLVED_OPENAPI && resolved.codegen.openApi) {
-				const primary = resolved.codegen.openApi[0]
+				const primary = resolved.codegen.openApi[0] as ResolvedOpenApiOutput
 				if (!config.app) throw new Error("OpenAPI virtual module requires app")
 				const appPath = resolve(root, config.app)
-				const exported = await loadDefaultWithJiti(appPath)
+				const exported = await loadAppOrTree(await createModuleLoader({ fresh: true, from: appPath }), appPath)
 				if (isHoneyApp(exported)) {
 					let spec = await generateOpenApi(exported, {
 						filterRoutes: primary.filterRoutes,
@@ -718,6 +798,9 @@ export function honey(config: HoneyVitePluginConfig) {
 							title: primary.title,
 							version: primary.version,
 						},
+						/* generation already reported; a virtual module load must not repeat it */
+						invalidate: "off",
+						profile: primary.profile,
 						securitySchemes: primary.securitySchemes,
 					})
 					if (primary.sanitize) {
@@ -734,20 +817,22 @@ export function honey(config: HoneyVitePluginConfig) {
 
 		name: "honey",
 
-		transform(code: string, id: string): { code: string; map: null } | undefined {
+		/**
+		 * Imports the entries of optional features a module uses, ahead of its code, on the same
+		 * line so line numbers stay put. Server environments only: browser code never serves.
+		 */
+		transform(this: PluginThis | void, code: string, id: string): { code: string; map: null } | undefined {
+			if (this && this.environment?.config?.consumer === "client") return undefined
 			if (id.includes("\0") || id.includes("node_modules")) return undefined
-			const inject: string[] = []
-			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")) {
-				inject.push('import { enableServe } from "@lovrozagar/honey/serve"', "enableServe()")
-			}
-			if (/\.errorI18n\s*\(/.test(code) && !code.includes("@lovrozagar/honey/i18n")) {
-				inject.push('import { enableI18n } from "@lovrozagar/honey/i18n"', "enableI18n()")
+			const features = [...detectFeaturesInSource(code)].filter((f) => !importsFeatureEntry(code, f))
+			if (features.length === 0) return undefined
+			const prelude = featurePrelude(features)
+			if (code.startsWith("#!")) {
+				const eol = code.indexOf("\n")
+				if (eol === -1) return { code: `${code}\n${prelude}`, map: null }
+				return { code: `${code.slice(0, eol + 1)}${prelude} ${code.slice(eol + 1)}`, map: null }
 			}
-			if (inject.length === 0) return undefined
-			return { code: `${inject.join("\n")}\n${code}`, map: null }
+			return { code: `${prelude} ${code}`, map: null }
 		},
 
 		resolveId(id: string): string | undefined {