elysia 1.4.28 → 2.0.0-beta.0

package/dist/plugin/aot/hooks.js

@@ -0,0 +1,114 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_plugin_aot_core = require('./core.js');
+const require_plugin_aot_treeshake = require('./treeshake.js');
+
+//#region src/plugin/aot/hooks.ts
+const toPosix = (path) => path.replace(/\\/g, "/");
+const VIRTUAL = "\0elysia/compiled";
+const VIRTUAL_TYPE = "\0elysia/type";
+const createAotPluginHooks = (entry, options) => {
+	const entryPath = require_plugin_aot_core.resolveEntry(entry);
+	const entryPosix = toPosix(entryPath);
+	const entryRealPosix = toPosix(require_plugin_aot_core.realPath(entryPath));
+	let entryMatched = false;
+	let initial = true;
+	const isEntry = (id) => {
+		const posix = toPosix(id);
+		if (posix === entryPosix || posix === entryRealPosix) return true;
+		return toPosix(require_plugin_aot_core.realPath(id)) === entryRealPosix;
+	};
+	const treeShake = options?.treeShake ?? true;
+	let source = "";
+	let virtualType;
+	let stub = { ...require_plugin_aot_core.NO_STUB };
+	let isElysiaModule = (_path) => false;
+	return {
+		async buildStart() {
+			const generated = initial ? await require_plugin_aot_core.generateCompiledArtifacts(entry, options) : await require_plugin_aot_core.generateCompiledArtifactsIsolated(entry, options);
+			initial = false;
+			source = generated.source;
+			stub = generated.stub;
+			virtualType = generated.virtualType;
+			isElysiaModule = require_plugin_aot_core.makeIsElysiaModule(require_plugin_aot_core.resolveElysiaRoot(entryPath));
+		},
+		buildEnd() {
+			if (!entryMatched) throw new Error(`[elysia-aot] entry "${entry}" never appeared in the Vite module graph. Compiled manifest was not injected. Check that the plugin entry matches a build input.`);
+		},
+		resolveId(id) {
+			if (id === "elysia/compiled") return VIRTUAL;
+			if (id === "elysia/type" && virtualType !== void 0) return VIRTUAL_TYPE;
+		},
+		load(id) {
+			if (id === VIRTUAL) return source;
+			if (id === VIRTUAL_TYPE) return virtualType;
+		},
+		async transform(code, id) {
+			const cleanId = id.split("?", 1)[0];
+			for (const key of Object.keys(require_plugin_aot_core.STUB_SOURCES)) {
+				if (!stub[key]) continue;
+				for (const { filter, source: stubSource } of require_plugin_aot_core.STUB_SOURCES[key]) if (filter.test(cleanId)) return require_plugin_aot_core.alignStubExtensions(stubSource, cleanId);
+			}
+			if (stub.adapter !== false && require_plugin_aot_core.ADAPTER_CONSTANTS_FILTER.test(cleanId)) return require_plugin_aot_core.alignStubExtensions(require_plugin_aot_core.adapterConstantsSource(stub.adapter), cleanId);
+			if (stub.adapter === "web-standard" && require_plugin_aot_core.ADAPTER_BUN_FILTER.test(cleanId)) return require_plugin_aot_core.alignStubExtensions(require_plugin_aot_core.bunAdapterStubSource, cleanId);
+			if (stub.isProduction && require_plugin_aot_core.IS_PRODUCTION_FILTER.test(cleanId)) return require_plugin_aot_core.alignStubExtensions(`export const isProduction = () => true\n`, cleanId);
+			let out = code;
+			if (treeShake && require_plugin_aot_core.SOURCE_REGEX.test(cleanId) && !cleanId.includes("node_modules")) out = require_plugin_aot_treeshake.rewriteTypeImport(out);
+			if (stub.isProduction && isElysiaModule(cleanId)) out = require_plugin_aot_core.rewriteIsProductionCalls(out);
+			if (isEntry(cleanId)) {
+				entryMatched = true;
+				out = `import 'elysia/compiled'\n${out}`;
+			}
+			return out === code ? void 0 : out;
+		},
+		isTransformCandidate(id) {
+			const cleanId = id.split("?", 1)[0];
+			if (isEntry(cleanId)) return true;
+			if (require_plugin_aot_core.ELYSIA_MODULE_FILTER.test(cleanId) || require_plugin_aot_core.ADAPTER_CONSTANTS_FILTER.test(cleanId) || require_plugin_aot_core.ADAPTER_BUN_FILTER.test(cleanId) || require_plugin_aot_core.IS_PRODUCTION_FILTER.test(cleanId)) return true;
+			for (const key of Object.keys(require_plugin_aot_core.STUB_SOURCES)) for (const { filter } of require_plugin_aot_core.STUB_SOURCES[key]) if (filter.test(cleanId)) return true;
+			if (require_plugin_aot_core.SOURCE_REGEX.test(cleanId) && !cleanId.includes("node_modules")) return true;
+			return false;
+		}
+	};
+};
+const resolveLoader = (path) => {
+	const ext = path.slice(path.lastIndexOf("."));
+	return ext === ".js" || ext === ".mjs" || ext === ".cjs" ? "js" : ext === ".jsx" ? "jsx" : ext === ".tsx" ? "tsx" : "ts";
+};
+async function setupAotOnLoad(build, hooks, { readText, resolveDir }) {
+	await hooks.buildStart();
+	const virtualLoad = (id) => () => ({
+		contents: hooks.load(id),
+		loader: "js",
+		...resolveDir !== void 0 ? { resolveDir } : {}
+	});
+	build.onResolve({ filter: /^elysia\/compiled$/ }, () => ({
+		path: "manifest",
+		namespace: "elysia-aot"
+	}));
+	build.onLoad({
+		filter: /.*/,
+		namespace: "elysia-aot"
+	}, virtualLoad(VIRTUAL));
+	build.onResolve({ filter: /^elysia\/type$/ }, () => hooks.resolveId("elysia/type") !== void 0 ? {
+		path: "elysia-type",
+		namespace: "elysia-aot-type"
+	} : void 0);
+	build.onLoad({
+		filter: /.*/,
+		namespace: "elysia-aot-type"
+	}, virtualLoad(VIRTUAL_TYPE));
+	build.onLoad({ filter: require_plugin_aot_core.SOURCE_REGEX }, async (args) => {
+		if (!hooks.isTransformCandidate(args.path)) return void 0;
+		const original = await readText(args.path);
+		const contents = await hooks.transform(original, args.path);
+		if (contents === void 0) return void 0;
+		return {
+			contents,
+			loader: resolveLoader(args.path)
+		};
+	});
+}
+
+//#endregion
+exports.createAotPluginHooks = createAotPluginHooks;
+exports.setupAotOnLoad = setupAotOnLoad;

package/dist/plugin/aot/hooks.mjs

@@ -0,0 +1,112 @@
+import { ADAPTER_BUN_FILTER, ADAPTER_CONSTANTS_FILTER, ELYSIA_MODULE_FILTER, IS_PRODUCTION_FILTER, NO_STUB, SOURCE_REGEX, STUB_SOURCES, adapterConstantsSource, alignStubExtensions, bunAdapterStubSource, generateCompiledArtifacts, generateCompiledArtifactsIsolated, makeIsElysiaModule, realPath, resolveElysiaRoot, resolveEntry, rewriteIsProductionCalls } from "./core.mjs";
+import { rewriteTypeImport } from "./treeshake.mjs";
+
+//#region src/plugin/aot/hooks.ts
+const toPosix = (path) => path.replace(/\\/g, "/");
+const VIRTUAL = "\0elysia/compiled";
+const VIRTUAL_TYPE = "\0elysia/type";
+const createAotPluginHooks = (entry, options) => {
+	const entryPath = resolveEntry(entry);
+	const entryPosix = toPosix(entryPath);
+	const entryRealPosix = toPosix(realPath(entryPath));
+	let entryMatched = false;
+	let initial = true;
+	const isEntry = (id) => {
+		const posix = toPosix(id);
+		if (posix === entryPosix || posix === entryRealPosix) return true;
+		return toPosix(realPath(id)) === entryRealPosix;
+	};
+	const treeShake = options?.treeShake ?? true;
+	let source = "";
+	let virtualType;
+	let stub = { ...NO_STUB };
+	let isElysiaModule = (_path) => false;
+	return {
+		async buildStart() {
+			const generated = initial ? await generateCompiledArtifacts(entry, options) : await generateCompiledArtifactsIsolated(entry, options);
+			initial = false;
+			source = generated.source;
+			stub = generated.stub;
+			virtualType = generated.virtualType;
+			isElysiaModule = makeIsElysiaModule(resolveElysiaRoot(entryPath));
+		},
+		buildEnd() {
+			if (!entryMatched) throw new Error(`[elysia-aot] entry "${entry}" never appeared in the Vite module graph. Compiled manifest was not injected. Check that the plugin entry matches a build input.`);
+		},
+		resolveId(id) {
+			if (id === "elysia/compiled") return VIRTUAL;
+			if (id === "elysia/type" && virtualType !== void 0) return VIRTUAL_TYPE;
+		},
+		load(id) {
+			if (id === VIRTUAL) return source;
+			if (id === VIRTUAL_TYPE) return virtualType;
+		},
+		async transform(code, id) {
+			const cleanId = id.split("?", 1)[0];
+			for (const key of Object.keys(STUB_SOURCES)) {
+				if (!stub[key]) continue;
+				for (const { filter, source: stubSource } of STUB_SOURCES[key]) if (filter.test(cleanId)) return alignStubExtensions(stubSource, cleanId);
+			}
+			if (stub.adapter !== false && ADAPTER_CONSTANTS_FILTER.test(cleanId)) return alignStubExtensions(adapterConstantsSource(stub.adapter), cleanId);
+			if (stub.adapter === "web-standard" && ADAPTER_BUN_FILTER.test(cleanId)) return alignStubExtensions(bunAdapterStubSource, cleanId);
+			if (stub.isProduction && IS_PRODUCTION_FILTER.test(cleanId)) return alignStubExtensions(`export const isProduction = () => true\n`, cleanId);
+			let out = code;
+			if (treeShake && SOURCE_REGEX.test(cleanId) && !cleanId.includes("node_modules")) out = rewriteTypeImport(out);
+			if (stub.isProduction && isElysiaModule(cleanId)) out = rewriteIsProductionCalls(out);
+			if (isEntry(cleanId)) {
+				entryMatched = true;
+				out = `import 'elysia/compiled'\n${out}`;
+			}
+			return out === code ? void 0 : out;
+		},
+		isTransformCandidate(id) {
+			const cleanId = id.split("?", 1)[0];
+			if (isEntry(cleanId)) return true;
+			if (ELYSIA_MODULE_FILTER.test(cleanId) || ADAPTER_CONSTANTS_FILTER.test(cleanId) || ADAPTER_BUN_FILTER.test(cleanId) || IS_PRODUCTION_FILTER.test(cleanId)) return true;
+			for (const key of Object.keys(STUB_SOURCES)) for (const { filter } of STUB_SOURCES[key]) if (filter.test(cleanId)) return true;
+			if (SOURCE_REGEX.test(cleanId) && !cleanId.includes("node_modules")) return true;
+			return false;
+		}
+	};
+};
+const resolveLoader = (path) => {
+	const ext = path.slice(path.lastIndexOf("."));
+	return ext === ".js" || ext === ".mjs" || ext === ".cjs" ? "js" : ext === ".jsx" ? "jsx" : ext === ".tsx" ? "tsx" : "ts";
+};
+async function setupAotOnLoad(build, hooks, { readText, resolveDir }) {
+	await hooks.buildStart();
+	const virtualLoad = (id) => () => ({
+		contents: hooks.load(id),
+		loader: "js",
+		...resolveDir !== void 0 ? { resolveDir } : {}
+	});
+	build.onResolve({ filter: /^elysia\/compiled$/ }, () => ({
+		path: "manifest",
+		namespace: "elysia-aot"
+	}));
+	build.onLoad({
+		filter: /.*/,
+		namespace: "elysia-aot"
+	}, virtualLoad(VIRTUAL));
+	build.onResolve({ filter: /^elysia\/type$/ }, () => hooks.resolveId("elysia/type") !== void 0 ? {
+		path: "elysia-type",
+		namespace: "elysia-aot-type"
+	} : void 0);
+	build.onLoad({
+		filter: /.*/,
+		namespace: "elysia-aot-type"
+	}, virtualLoad(VIRTUAL_TYPE));
+	build.onLoad({ filter: SOURCE_REGEX }, async (args) => {
+		if (!hooks.isTransformCandidate(args.path)) return void 0;
+		const original = await readText(args.path);
+		const contents = await hooks.transform(original, args.path);
+		if (contents === void 0) return void 0;
+		return {
+			contents,
+			loader: resolveLoader(args.path)
+		};
+	});
+}
+
+//#endregion
+export { createAotPluginHooks, setupAotOnLoad };

package/dist/plugin/aot/rspack-loader.d.ts

@@ -0,0 +1,23 @@
+import { AotPluginHooks } from "./hooks.js";
+
+//#region src/plugin/aot/rspack-loader.d.ts
+declare function registerAotHooks(token: string, hooks: AotPluginHooks): void;
+declare function unregisterAotHooks(token: string): void;
+interface AotLoaderContext {
+  resourcePath: string;
+  getOptions(): {
+    token?: string;
+  } | undefined;
+  async(): (err: Error | null | undefined, content?: string, sourceMap?: unknown) => void;
+}
+/**
+ * webpack/rspack-style JS loader. Delegates to `hooks.transform`, which returns
+ * `undefined` for any module it doesn't rewrite so the loader passes the source through unchanged.
+ * `enforce: 'pre'` runs this before the swc/babel loaders, mirroring unplugin's `enforce: 'pre'`.
+ *
+ * Uses `this.async()` because `hooks.transform` can be async (isolated
+ * regeneration in watch flows).
+ */
+declare function elysiaAotLoader(this: AotLoaderContext, source: string): void;
+//#endregion
+export { elysiaAotLoader as default, registerAotHooks, unregisterAotHooks };

package/dist/plugin/aot/rspack-loader.js

@@ -0,0 +1,44 @@
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+//#region src/plugin/aot/rspack-loader.ts
+/**
+* Shared, same-process registry mapping an opaque token -> the plugin instance's
+* hooks. rspack loaders run in the same process as the plugin, so the plugin
+* registers its `hooks` under a per-instance token (see `rspack.ts`) and passes
+* the token through the rule's loader `options`; this loader looks it up here.
+*
+* This is the standard "loader can't close over plugin state, so pass a token
+* through options and resolve it from a module-global map" trick. Keyed per
+* plugin instance so concurrent compilers / multiple plugin instances don't
+* clobber each other.
+*/
+const registry = /* @__PURE__ */ new Map();
+function registerAotHooks(token, hooks) {
+	registry.set(token, hooks);
+}
+function unregisterAotHooks(token) {
+	registry.delete(token);
+}
+/**
+* webpack/rspack-style JS loader. Delegates to `hooks.transform`, which returns
+* `undefined` for any module it doesn't rewrite so the loader passes the source through unchanged.
+* `enforce: 'pre'` runs this before the swc/babel loaders, mirroring unplugin's `enforce: 'pre'`.
+*
+* Uses `this.async()` because `hooks.transform` can be async (isolated
+* regeneration in watch flows).
+*/
+function elysiaAotLoader(source) {
+	const callback = this.async();
+	const token = this.getOptions()?.token;
+	const hooks = token ? registry.get(token) : void 0;
+	if (!hooks) {
+		callback(null, source);
+		return;
+	}
+	Promise.resolve(hooks.transform(source, this.resourcePath)).then((out) => callback(null, out === void 0 ? source : out), (error) => callback(error));
+}
+
+//#endregion
+exports.default = elysiaAotLoader;
+exports.registerAotHooks = registerAotHooks;
+exports.unregisterAotHooks = unregisterAotHooks;

package/dist/plugin/aot/rspack-loader.mjs

@@ -0,0 +1,40 @@
+//#region src/plugin/aot/rspack-loader.ts
+/**
+* Shared, same-process registry mapping an opaque token -> the plugin instance's
+* hooks. rspack loaders run in the same process as the plugin, so the plugin
+* registers its `hooks` under a per-instance token (see `rspack.ts`) and passes
+* the token through the rule's loader `options`; this loader looks it up here.
+*
+* This is the standard "loader can't close over plugin state, so pass a token
+* through options and resolve it from a module-global map" trick. Keyed per
+* plugin instance so concurrent compilers / multiple plugin instances don't
+* clobber each other.
+*/
+const registry = /* @__PURE__ */ new Map();
+function registerAotHooks(token, hooks) {
+	registry.set(token, hooks);
+}
+function unregisterAotHooks(token) {
+	registry.delete(token);
+}
+/**
+* webpack/rspack-style JS loader. Delegates to `hooks.transform`, which returns
+* `undefined` for any module it doesn't rewrite so the loader passes the source through unchanged.
+* `enforce: 'pre'` runs this before the swc/babel loaders, mirroring unplugin's `enforce: 'pre'`.
+*
+* Uses `this.async()` because `hooks.transform` can be async (isolated
+* regeneration in watch flows).
+*/
+function elysiaAotLoader(source) {
+	const callback = this.async();
+	const token = this.getOptions()?.token;
+	const hooks = token ? registry.get(token) : void 0;
+	if (!hooks) {
+		callback(null, source);
+		return;
+	}
+	Promise.resolve(hooks.transform(source, this.resourcePath)).then((out) => callback(null, out === void 0 ? source : out), (error) => callback(error));
+}
+
+//#endregion
+export { elysiaAotLoader as default, registerAotHooks, unregisterAotHooks };

package/dist/plugin/aot/rspack.d.ts

@@ -0,0 +1,23 @@
+import { ElysiaAotOptions } from "./core.js";
+
+//#region src/plugin/aot/rspack.d.ts
+/**
+ * Elysia AOT build plugin
+ *
+ * Run Elysia JIT compilation at build time instead of runtime.
+ *
+ * ```ts
+ * // rspack.config.ts
+ * import { aot } from 'elysia/plugin/aot/rspack'
+ *
+ * export default {
+ *   plugins: [aot('src/index.ts')]
+ * }
+ * ```
+ */
+declare const aot: (entry: string, options?: ElysiaAotOptions) => {
+  name: string;
+  apply(compiler: unknown): void;
+};
+//#endregion
+export { aot, aot as default };

package/dist/plugin/aot/rspack.js

@@ -0,0 +1,85 @@
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+const require_runtime = require('../../_virtual/_rolldown/runtime.js');
+const require_plugin_aot_core = require('./core.js');
+const require_plugin_aot_hooks = require('./hooks.js');
+const require_plugin_aot_rspack_loader = require('./rspack-loader.js');
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+let node_url = require("node:url");
+let node_crypto = require("node:crypto");
+
+//#region src/plugin/aot/rspack.ts
+const PLUGIN = "elysia-aot";
+let tokenCounter = 0;
+function loaderPath() {
+	const moduleUrl = require("url").pathToFileURL(__filename).href;
+	return (0, node_path.resolve)((0, node_path.dirname)((0, node_url.fileURLToPath)(moduleUrl)), "rspack-loader" + require_plugin_aot_core.siblingModuleExt(moduleUrl));
+}
+/**
+* Elysia AOT build plugin
+*
+* Run Elysia JIT compilation at build time instead of runtime.
+*
+* ```ts
+* // rspack.config.ts
+* import { aot } from 'elysia/plugin/aot/rspack'
+*
+* export default {
+*   plugins: [aot('src/index.ts')]
+* }
+* ```
+*/
+const aot = (entry, options) => {
+	const hooks = require_plugin_aot_hooks.createAotPluginHooks(entry, options);
+	const entryPath = require_plugin_aot_core.resolveEntry(entry);
+	const token = `${PLUGIN}:${entryPath}:${tokenCounter++}`;
+	const cacheDir = (0, node_path.join)(process.cwd(), "node_modules", ".cache", "elysia-aot", (0, node_crypto.createHash)("sha1").update(entryPath).digest("hex").slice(0, 16));
+	const manifestFile = (0, node_path.join)(cacheDir, "compiled.mjs");
+	const typeFile = (0, node_path.join)(cacheDir, "type.mjs");
+	const apply = (rawCompiler) => {
+		const compiler = rawCompiler;
+		compiler.options.module.rules.push({
+			test: (id) => hooks.isTransformCandidate(id.split("?", 1)[0]),
+			enforce: "pre",
+			use: [{
+				loader: loaderPath(),
+				options: { token }
+			}]
+		});
+		compiler.options.module.rules.push({
+			test: (id) => id.split("?", 1)[0] === manifestFile,
+			sideEffects: true
+		});
+		compiler.hooks.beforeCompile.tapPromise(PLUGIN, async () => {
+			require_plugin_aot_rspack_loader.registerAotHooks(token, hooks);
+			await hooks.buildStart();
+			const source = hooks.load(hooks.resolveId("elysia/compiled"));
+			const typeId = hooks.resolveId("elysia/type");
+			const virtualType = typeId === void 0 ? void 0 : hooks.load(typeId);
+			(0, node_fs.mkdirSync)(cacheDir, { recursive: true });
+			(0, node_fs.writeFileSync)(manifestFile, source ?? "");
+			const resolveOptions = compiler.options.resolve ??= {};
+			const alias = resolveOptions.alias ??= {};
+			alias["elysia/compiled$"] = manifestFile;
+			if (virtualType !== void 0) {
+				(0, node_fs.writeFileSync)(typeFile, virtualType);
+				alias["elysia/type$"] = typeFile;
+			} else delete alias["elysia/type$"];
+		});
+		compiler.hooks.afterCompile.tapPromise(PLUGIN, async () => {
+			try {
+				hooks.buildEnd();
+			} finally {
+				require_plugin_aot_rspack_loader.unregisterAotHooks(token);
+			}
+		});
+	};
+	return {
+		name: PLUGIN,
+		apply
+	};
+};
+
+//#endregion
+exports.aot = aot;
+exports.default = aot;

package/dist/plugin/aot/rspack.mjs

@@ -0,0 +1,82 @@
+import { resolveEntry, siblingModuleExt } from "./core.mjs";
+import { createAotPluginHooks } from "./hooks.mjs";
+import { registerAotHooks, unregisterAotHooks } from "./rspack-loader.mjs";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createHash } from "node:crypto";
+
+//#region src/plugin/aot/rspack.ts
+const PLUGIN = "elysia-aot";
+let tokenCounter = 0;
+function loaderPath() {
+	const moduleUrl = import.meta.url;
+	return resolve(dirname(fileURLToPath(moduleUrl)), "rspack-loader" + siblingModuleExt(moduleUrl));
+}
+/**
+* Elysia AOT build plugin
+*
+* Run Elysia JIT compilation at build time instead of runtime.
+*
+* ```ts
+* // rspack.config.ts
+* import { aot } from 'elysia/plugin/aot/rspack'
+*
+* export default {
+*   plugins: [aot('src/index.ts')]
+* }
+* ```
+*/
+const aot = (entry, options) => {
+	const hooks = createAotPluginHooks(entry, options);
+	const entryPath = resolveEntry(entry);
+	const token = `${PLUGIN}:${entryPath}:${tokenCounter++}`;
+	const cacheDir = join(process.cwd(), "node_modules", ".cache", "elysia-aot", createHash("sha1").update(entryPath).digest("hex").slice(0, 16));
+	const manifestFile = join(cacheDir, "compiled.mjs");
+	const typeFile = join(cacheDir, "type.mjs");
+	const apply = (rawCompiler) => {
+		const compiler = rawCompiler;
+		compiler.options.module.rules.push({
+			test: (id) => hooks.isTransformCandidate(id.split("?", 1)[0]),
+			enforce: "pre",
+			use: [{
+				loader: loaderPath(),
+				options: { token }
+			}]
+		});
+		compiler.options.module.rules.push({
+			test: (id) => id.split("?", 1)[0] === manifestFile,
+			sideEffects: true
+		});
+		compiler.hooks.beforeCompile.tapPromise(PLUGIN, async () => {
+			registerAotHooks(token, hooks);
+			await hooks.buildStart();
+			const source = hooks.load(hooks.resolveId("elysia/compiled"));
+			const typeId = hooks.resolveId("elysia/type");
+			const virtualType = typeId === void 0 ? void 0 : hooks.load(typeId);
+			mkdirSync(cacheDir, { recursive: true });
+			writeFileSync(manifestFile, source ?? "");
+			const resolveOptions = compiler.options.resolve ??= {};
+			const alias = resolveOptions.alias ??= {};
+			alias["elysia/compiled$"] = manifestFile;
+			if (virtualType !== void 0) {
+				writeFileSync(typeFile, virtualType);
+				alias["elysia/type$"] = typeFile;
+			} else delete alias["elysia/type$"];
+		});
+		compiler.hooks.afterCompile.tapPromise(PLUGIN, async () => {
+			try {
+				hooks.buildEnd();
+			} finally {
+				unregisterAotHooks(token);
+			}
+		});
+	};
+	return {
+		name: PLUGIN,
+		apply
+	};
+};
+
+//#endregion
+export { aot, aot as default };

package/dist/plugin/aot/source.d.ts

@@ -0,0 +1,60 @@
+import { AotFingerprint, CapturedHandler, CapturedValidator } from "../../compile/aot.js";
+import { AnyElysia } from "../../base.js";
+import { JITProbeResult } from "../../compile/jit-probe.js";
+
+//#region src/plugin/aot/source.d.ts
+type AotTarget = 'bun' | 'node' | 'workerd';
+interface CompileToSourceOptions {
+  /** Emit a self-registering fingerprinted program (`Compiled.register(...)`). */
+  register?: boolean;
+  /**
+   * Deploy target for build-time-baked codegen consts. Lets you build on one
+   * runtime and deploy to another e.g. build under Bun with
+   * `target: 'workerd'` so the manifest bakes `Object.fromEntries(...)` instead
+   * of the Bun-only `Headers.toJSON()`. Removes the need to generate the
+   * manifest under Node for a workerd deploy.
+   *
+   * @default the build runtime
+   */
+  target?: AotTarget;
+  /**
+   * Split the emitted validator manifest into lazily-materialized groups
+   *
+   * Validator entries are registered as grouped thunks: a group's
+   * validators are constructed on the first request to any route in that
+   * group, trading first-request latency in unbuilt groups for lower
+   * startup cost. Handlers are always eager. Only validator construction
+   * is deferred. Pass a number to set the group size explicitly.
+   *
+   * @default decided by Elysia based on route batch scale
+   */
+  lazy?: boolean | number;
+  /**
+   * Specifier the generated module imports `Compiled` from
+   * Must resolve to the same `elysia` instance the app runs
+   *
+   * @default 'elysia'
+   */
+  registerFrom?: string;
+  /**
+   * Specifier the generated module imports the `Reconstruct` table from,
+   * only emitted when the manifest carries validators. The table is pure,
+   * so unlike `registerFrom` it may resolve to any elysia copy the
+   * registration itself goes through `Compiled` (from `registerFrom`)
+   *
+   * @default 'elysia/reconstruct'
+   */
+  reconstructFrom?: string;
+}
+declare const autoGroupSize: (routes: number) => number;
+declare function compileToSource(app: AnyElysia, options?: CompileToSourceOptions): Promise<string>;
+interface CapturedArtifacts {
+  source: string;
+  validators: CapturedValidator[];
+  handlers: CapturedHandler[];
+  fingerprint: AotFingerprint;
+}
+declare function captureArtifacts(app: AnyElysia, options?: CompileToSourceOptions): Promise<CapturedArtifacts>;
+declare function replayStubbability(app: AnyElysia, handlers: CapturedHandler[]): JITProbeResult;
+//#endregion
+export { AotTarget, CapturedArtifacts, CompileToSourceOptions, autoGroupSize, captureArtifacts, compileToSource, replayStubbability };