elysia 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/plugin/aot/core.js

@@ -20,8 +20,31 @@ function findPackageRoot(from = process.cwd()) {
 	return dir;
 }
 const resolveEntry = (entry) => (0, node_path.resolve)(findPackageRoot(), entry);
+/** @internal Resolve the package condition used to evaluate an AOT entry. */
+const resolveEntryModuleKind = (entry) => {
+	const entryPath = resolveEntry(entry);
+	switch ((0, node_path.extname)(entryPath)) {
+		case ".cjs":
+		case ".cts": return "cjs";
+		case ".mjs":
+		case ".mts":
+		case ".ts":
+		case ".tsx": return "esm";
+		case ".js":
+		case ".jsx": {
+			const packagePath = (0, node_path.join)(findPackageRoot((0, node_path.dirname)(entryPath)), "package.json");
+			if (!(0, node_fs.existsSync)(packagePath)) return "cjs";
+			const pkg = JSON.parse((0, node_fs.readFileSync)(packagePath, "utf8"));
+			if (pkg.type === "module") return "esm";
+			if (pkg.type === void 0 || pkg.type === "commonjs") return "cjs";
+			throw new Error(`[elysia-aot] package.json has unsupported "type" ${JSON.stringify(pkg.type)} for JavaScript entry ${JSON.stringify(entryPath)}.`);
+		}
+		default: throw new Error(`[elysia-aot] entry ${JSON.stringify(entryPath)} has an ambiguous module condition. Use a .cjs/.cts CommonJS entry or a .mjs/.mts/.ts/.tsx ESM entry; .js/.jsx follows the nearest package.json "type".`);
+	}
+};
 const NO_STUB = {
 	jit: false,
+	staticClone: false,
 	ws: false,
 	reconstruct: false,
 	cookie: false,
@@ -29,6 +52,8 @@ const NO_STUB = {
 	sucrose: false,
 	compat: false,
 	bridge: false,
+	typeboxValue: false,
+	exactMirror: false,
 	adapter: false,
 	isProduction: false
 };
@@ -49,20 +74,23 @@ const NO_STUB = {
 *   is not active, so the bridge must stay wired the ordinary way. No compat
 *   stub, no reroute.
 */
-function planFromReport(strip, report, hasWS, mayTrace, aliases, allBridgeFree, zeroCapture, adapterStub = false, productionStub = true) {
+function planFromReport(strip, report, hasWS, mayTrace, aliases, allBridgeFree, zeroCapture, adapterStub = false, productionStub = true, wsCookie = false, exactMirror = false) {
 	const jit = report.jit;
 	if (strip === true && !jit) throw new Error(`[elysia-aot] strip: true requires every route to be covered by the AOT handler manifest, but handler JIT is still reachable (${report.reasons.join(", ") || "unknown"}). Use strip: 'auto' to skip stubbing when the app is not fully precompiled.`);
 	const mode = !jit ? "off" : allBridgeFree ? "sealed" : hasWS && zeroCapture ? "off" : "wired";
 	return {
 		plan: {
 			jit,
+			staticClone: jit && !aliases.has("scl"),
 			ws: !hasWS,
 			reconstruct: jit && !aliases.has("va") && !aliases.has("cc") && !aliases.has("tr"),
-			cookie: jit && !aliases.has("cc"),
+			cookie: jit && !aliases.has("cc") && !wsCookie,
 			trace: !aliases.has("tr") && (jit || !mayTrace),
 			sucrose: jit,
 			compat: mode !== "off",
 			bridge: mode === "wired",
+			typeboxValue: mode !== "sealed",
+			exactMirror: exactMirror && mode !== "sealed",
 			adapter: adapterStub,
 			isProduction: productionStub
 		},
@@ -73,71 +101,48 @@ function adapterConstantsSource(target) {
 	if (target === "bun") return "import { BunAdapter } from './bun/index'\nexport const defaultAdapter = BunAdapter\n";
 	return "import { WebStandardAdapter } from './web-standard/index'\nexport const defaultAdapter = WebStandardAdapter\n";
 }
-/** Filter matching elysia's own `adapter/constants` module (src + dist). */
 const ADAPTER_CONSTANTS_FILTER = /[\\/]elysia[\\/](dist|src)[\\/]adapter[\\/]constants\.(m?js|ts)$/;
 const ADAPTER_BUN_FILTER = /[\\/]elysia[\\/](dist|src)[\\/]adapter[\\/]bun[\\/]index\.(m?js|ts)$/;
 const IS_PRODUCTION_FILTER = /[\\/]elysia[\\/](dist|src)[\\/]universal[\\/]is-production\.(m?js|ts)$/;
-/**
-* Loose fallback filter
-*
-* Matches the `/elysia/(dist|src)/` segment anywhere in a path (node_modules layouts,
-* monorepos, linked installs). Used by esbuild as a broad pre-filter
-*
-* The caller must further check that the path is under the resolved elysia package root
-* to avoid matching user code in a directory that happens to be named "elysia"
-*
-* @internal
-*/
+const TYPEBOX_TYPE_FILTER = /[\\/]elysia[\\/](dist|src)[\\/]type[\\/]typebox-type\.(m?js|ts)$/;
+const TYPEBOX_SYSTEM_LITE_FILTER = /[\\/]elysia[\\/](dist|src)[\\/]type[\\/]typebox-system-lite\.(m?js|ts)$/;
+const TYPEBOX_REQUIRE_FILTER = /[\\/]elysia[\\/](dist|src)[\\/]type[\\/]typebox-value-require\.(m?js|ts)$/;
+const EXACT_MIRROR_REQUIRE_FILTER = /[\\/]elysia[\\/](dist|src)[\\/]type[\\/]validator[\\/]exact-mirror-require\.(m?js|ts)$/;
 const ELYSIA_MODULE_FILTER = /[\\/]elysia[\\/](dist|src)[\\/].+\.(m?js|ts)x?$/;
-/**
-* Build a predicate that returns `true` only for modules that are under the
-* resolved elysia package root (i.e. actually elysia's own files).
-*
-* Anchoring to the real package root prevents user projects rooted in a
-* directory named `elysia` (like this repo itself) from having their code
-* rewritten.
-*
-* Pass the result to both the esbuild `filter` (convert to RegExp via
-* `makeElysiaModuleFilterRegex`) and the Vite transform (`isElysiaModule`).
-*/
-function resolveElysiaRoot(from = process.cwd()) {
+function resolveElysiaRoot(from) {
 	try {
 		return (0, node_path.dirname)((0, node_module.createRequire)((0, node_path.join)(from, "package.json")).resolve("elysia/package.json"));
 	} catch {
 		return from;
 	}
 }
-/**
-* Returns a predicate that is `true` only when the given module path is under
-* the resolved elysia package root AND matches the broad module filter.
-*/
+function resolveExactMirror(from) {
+	try {
+		(0, node_module.createRequire)((0, node_path.join)(resolveElysiaRoot(from), "package.json")).resolve("exact-mirror");
+		return true;
+	} catch {
+		return false;
+	}
+}
 function makeIsElysiaModule(elysiaRoot) {
 	const root = elysiaRoot.replace(/\\/g, "/");
 	return (path) => {
 		return path.replace(/\\/g, "/").startsWith(root + "/") && ELYSIA_MODULE_FILTER.test(path);
 	};
 }
-/**
-* Build an esbuild-compatible RegExp that anchors to the resolved elysia root
-* so the `onLoad` pre-filter is as tight as possible. esbuild uses this as an
-* initial path filter before calling the callback, so we still double-check
-* with `makeIsElysiaModule` inside the callback.
-*/
-function makeElysiaModuleFilterRegex(elysiaRoot) {
-	const escaped = elysiaRoot.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-	return new RegExp("^" + escaped + "[\\\\/](dist|src)[\\\\/].+\\.(m?js|ts)x?$");
-}
-function rewriteIsProductionCalls(code) {
-	return code.replace(/(?<![.?])\bisProduction\(\)/g, "true");
-}
-const bunAdapterStubSource = "const e=(t)=>{throw new Error(`[elysia-aot] Bun adapter was stripped for target 'web-standard' .listen() is unavailable; use the exported fetch handler or rebuild with a different target.`)}\nexport const BunAdapter={name:'bun',runtime:'bun',isWebStandard:true,parse:{},response:{},listen:e}\nexport function collectStaticRoutes(){}\n";
+const rewriteIsProductionCalls = (code) => code.replace(/(?<![.?])\bisProduction\(\)/g, "true");
+const bunAdapterStubSource = "const e=(t)=>{throw new Error(`[elysia-aot] Bun adapter was stripped for target 'web-standard' .listen() is unavailable; use the exported fetch handler or rebuild with a different target.`)}\nexport const BunAdapter={parse:{},response:{},listen:e}\nexport function collectStaticRoutes(){}\n";
 const STUB_SOURCES = {
+	staticClone: [{
+		filter: /[\\/]elysia[\\/](dist|src)[\\/]compile[\\/]handler[\\/]static-clone-resolver\.(m?js|ts)$/,
+		source: `export const staticCloneResolver = undefined\n`
+	}],
 	jit: [{
 		filter: /[\\/]elysia[\\/](dist|src)[\\/]compile[\\/]handler[\\/]jit\.(m?js|ts)$/,
 		source: "const e=()=>{throw new Error(\"[elysia-aot] handler compiler JIT was stripped (strip mode) but a route needed runtime compilation. Rebuild with strip:false.\")}\nexport function compileHandlerJit(){return e()}\nexport function createInlineHandler(){return e()}\nexport function setCaptureHeaderShorthand(){}\n"
 	}, {
 		filter: /[\\/]elysia[\\/](dist|src)[\\/]compile[\\/]handler[\\/]descriptor\.(m?js|ts)$/,
-		source: "const e=()=>{throw new Error(\"[elysia-aot] handler compiler JIT was stripped (strip mode) but a route needed runtime compilation. Rebuild with strip:false.\")}\nexport function describeRoute(){return e()}\nexport const routeDescriptors=new WeakMap()\nexport function isEmptyPipelineHook(hook){\n	if(!hook)return true\n	for(const key in hook){\n		if(key==='detail'||key==='tags')continue\n		const value=hook[key]\n		if(value!==undefined&&value!==false&&(!Array.isArray(value)||value.length))return false\n	}\n	return true\n}\n"
+		source: "const e=()=>{throw new Error(\"[elysia-aot] handler compiler JIT was stripped (strip mode) but a route needed runtime compilation. Rebuild with strip:false.\")}\nexport function describeRoute(){return e()}\nexport const routeDescriptors=new WeakMap()\n"
 	}],
 	ws: [{
 		filter: /[\\/]elysia[\\/](dist|src)[\\/]ws[\\/]route\.(m?js|ts)$/,
@@ -147,13 +152,20 @@ const STUB_SOURCES = {
 		filter: /[\\/]elysia[\\/](dist|src)[\\/]compile[\\/]handler[\\/]reconstruct\.(m?js|ts)$/,
 		source: "const e=()=>{throw new Error(\"[elysia-aot] handler reconstruction was stripped (strip mode) but a route needed it. Rebuild with strip:false.\")}\nexport class Reconstrct {\n  static validator(){return e()}\n  static cookie(){return e()}\n  static trace(){return e()}\n}\n"
 	}],
-	cookie: [{
-		filter: /[\\/]elysia[\\/](dist|src)[\\/]cookie[\\/]utils\.(m?js|ts)$/,
-		source: "const e=()=>{throw new Error(\"[elysia-aot] cookie support was stripped (strip mode) but a route used cookies. Rebuild with strip:false.\")}\nexport const hasSyncHmac=false\nexport function parseCookie(){return e()}\nexport function parseCookieRaw(){return e()}\nexport function parseCookieRawSync(){return e()}\nexport function parseCookieRawSigned(){return e()}\nexport function parseCookieRawLazy(){return e()}\nexport function parseCookieRawDeferred(){return e()}\nexport function buildCookieJar(){return e()}\nexport function signCookieValues(){return e()}\nexport function signCookie(){return e()}\nexport function signCookieSubtle(){return e()}\nexport function signCookieSync(){return e()}\nexport function unsignCookie(){return e()}\nexport function unsignCookieSync(){return e()}\n"
-	}, {
-		filter: /[\\/]elysia[\\/](dist|src)[\\/]cookie[\\/]config\.(m?js|ts)$/,
-		source: "const e=()=>{throw new Error(\"[elysia-aot] cookie support was stripped (strip mode) but a route used cookies. Rebuild with strip:false.\")}\nexport function compileCookieConfig(){return e()}\nexport function isCookieSigned(){return e()}\n"
-	}],
+	cookie: [
+		{
+			filter: /[\\/]elysia[\\/](dist|src)[\\/]cookie[\\/]crypto\.(m?js|ts)$/,
+			source: `export function resolvePendingCookie(){throw new Error("[elysia-aot] cookie support was stripped (strip mode) but a signed cookie was read. Rebuild with strip:false.")}\n`
+		},
+		{
+			filter: /[\\/]elysia[\\/](dist|src)[\\/]cookie[\\/]utils\.(m?js|ts)$/,
+			source: "const e=()=>{throw new Error(\"[elysia-aot] cookie support was stripped (strip mode) but a route used cookies. Rebuild with strip:false.\")}\nexport const hasSyncHmac=false\nexport function parseCookieRaw(){return e()}\nexport function parseCookieRawSync(){return e()}\nexport function parseCookieRawSigned(){return e()}\nexport function parseCookieRawLazy(){return e()}\nexport function parseCookieRawDeferred(){return e()}\nexport function buildCookieJar(){return e()}\nexport function signCookieValues(){return e()}\n"
+		},
+		{
+			filter: /[\\/]elysia[\\/](dist|src)[\\/]cookie[\\/]config\.(m?js|ts)$/,
+			source: "const e=()=>{throw new Error(\"[elysia-aot] cookie support was stripped (strip mode) but a route used cookies. Rebuild with strip:false.\")}\nexport function compileCookieConfig(){return e()}\n"
+		}
+	],
 	trace: [{
 		filter: /[\\/]elysia[\\/](dist|src)[\\/]trace\.(m?js|ts)$/,
 		source: "const e=()=>{throw new Error(\"[elysia-aot] trace support was stripped (strip mode) but a route used trace. Rebuild with strip:false.\")}\nexport function createTracer(){return e()}\nexport function unionTracePhases(){return new Set()}\n"
@@ -161,9 +173,6 @@ const STUB_SOURCES = {
 	sucrose: [{
 		filter: /[\\/]elysia[\\/](dist|src)[\\/]memory\.(m?js|ts)$/,
 		source: "import { clearContextCache } from './context'\nimport { Validator } from './validator'\nexport function flushMemory() {\n	clearContextCache()\n	Validator.clear()\n}\n"
-	}, {
-		filter: /[\\/]elysia[\\/](dist|src)[\\/]compile[\\/]analysis-cache\.(m?js|ts)$/,
-		source: "import { clearHandlerAnalysisCaches } from './handler/index'\nimport { clearFlattenChainMemo } from '../utils'\nexport function clearAuthoringAnalysisCaches(root) {\n	clearHandlerAnalysisCaches(root)\n	clearFlattenChainMemo(root)\n}\n"
 	}],
 	compat: [{
 		filter: /[\\/]elysia[\\/](dist|src)[\\/]type[\\/]compat\.(m?js|ts)$/,
@@ -172,11 +181,23 @@ const STUB_SOURCES = {
 	bridge: [{
 		filter: /[\\/]elysia[\\/](dist|src)[\\/]type[\\/]bridge\.(m?js|ts)$/,
 		source: `export * from './bridge-live'\n`
+	}],
+	typeboxValue: [{
+		filter: /[\\/]elysia[\\/](dist|src)[\\/]type[\\/]typebox-value\.(m?js|ts)$/,
+		source: `export * from './typebox-value-live'\n`
+	}],
+	exactMirror: [{
+		filter: /[\\/]elysia[\\/](dist|src)[\\/]type[\\/]validator[\\/]exact-mirror\.(m?js|ts)$/,
+		source: `export * from './exact-mirror-live'\n`
 	}]
 };
 const alignStubExtensions = (stubSource, targetPath) => {
 	const ext = targetPath.slice(targetPath.lastIndexOf("."));
 	if (ext !== ".mjs" && ext !== ".js" && ext !== ".cjs") return stubSource;
+	if (ext !== ".mjs") {
+		const reexport = /^export \* from '(\.[^']+)'\n$/.exec(stubSource);
+		if (reexport) return `let m;const t=()=>m??=require('${reexport[1]}${ext}'),d=(o,k)=>Reflect.getOwnPropertyDescriptor(o,k)\nmodule.exports=new Proxy({},{get:(_,k)=>t()[k],has:(_,k)=>k in t(),ownKeys:()=>Reflect.ownKeys(t()),getOwnPropertyDescriptor:(o,k)=>{let x=d(o,k);if(x)return x;x=d(t(),k);if(x)x.configurable=true;return x},preventExtensions:o=>{for(const k of Reflect.ownKeys(t()))Object.defineProperty(o,k,d(t(),k));return Reflect.preventExtensions(o)}})\n`;
+	}
 	return stubSource.replace(/(from ')(\.[^']+)(')/g, (_m, open, spec, close) => open + (spec === "./validator" ? spec + "/index" : spec) + ext + close);
 };
 const OVERRIDE_MAP = {
@@ -204,6 +225,10 @@ const OVERRIDE_MAP = {
 		leaf: "boolean-string",
 		export: "BooleanString"
 	},
+	Composite: {
+		leaf: "keep-config",
+		export: "CompositeType"
+	},
 	Cookie: {
 		leaf: "cookie",
 		export: "Cookie"
@@ -212,6 +237,10 @@ const OVERRIDE_MAP = {
 		leaf: "date",
 		export: "DateType"
 	},
+	Evaluate: {
+		leaf: "keep-config",
+		export: "EvaluateType"
+	},
 	File: {
 		leaf: "file",
 		export: "File"
@@ -232,10 +261,18 @@ const OVERRIDE_MAP = {
 		leaf: "integer-string",
 		export: "IntegerString"
 	},
+	Interface: {
+		leaf: "keep-config",
+		export: "InterfaceType"
+	},
 	Intersect: {
 		leaf: "intersect",
 		export: "Intersect"
 	},
+	Mapped: {
+		leaf: "keep-config",
+		export: "MappedType"
+	},
 	MaybeEmpty: {
 		leaf: "maybe-empty",
 		export: "MaybeEmpty"
@@ -268,10 +305,34 @@ const OVERRIDE_MAP = {
 		leaf: "object-string",
 		export: "ObjectString"
 	},
+	Omit: {
+		leaf: "keep-config",
+		export: "OmitType"
+	},
 	Optional: {
 		leaf: "optional",
 		export: "Optional"
 	},
+	Partial: {
+		leaf: "keep-config",
+		export: "PartialType"
+	},
+	Pick: {
+		leaf: "keep-config",
+		export: "PickType"
+	},
+	Problem: {
+		leaf: "problem",
+		export: "Problem"
+	},
+	ReadonlyObject: {
+		leaf: "keep-config",
+		export: "ReadonlyObjectType"
+	},
+	Required: {
+		leaf: "keep-config",
+		export: "RequiredType"
+	},
 	String: {
 		leaf: "string",
 		export: "StringType"
@@ -290,17 +351,20 @@ const OVERRIDE_MAP = {
 	}
 };
 const requireFromHere = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
-const resolveSpecifier = (specifier) => {
-	const meta = {};
-	if (typeof meta.resolve === "function") {
-		const url = meta.resolve(specifier);
-		return url.startsWith("file://") ? new URL(url).pathname : url;
+const moduleMeta = {};
+const loadedModuleCondition = require("url").pathToFileURL(__filename).href.endsWith(".js") ? "cjs" : "esm";
+const resolveSpecifier = (specifier, moduleCondition) => {
+	if (moduleCondition === "cjs") return requireFromHere.resolve(specifier);
+	if (moduleMeta.resolve) {
+		const url = moduleMeta.resolve(specifier);
+		return url.startsWith("file://") ? (0, node_url.fileURLToPath)(url) : url;
 	}
+	if (moduleCondition === "esm") throw new Error("[elysia-aot] CommonJS-loaded build plugin cannot resolve the ESM package condition. Load the build plugin through import for an ESM entry.");
 	return requireFromHere.resolve(specifier);
 };
-async function generateVirtualType(typeSpecifier = "elysia/type") {
-	const typePath = resolveSpecifier(typeSpecifier);
-	const typeboxPath = resolveSpecifier("typebox/type");
+async function generateVirtualType(moduleCondition) {
+	const typePath = resolveSpecifier("elysia/type", moduleCondition);
+	const typeboxPath = resolveSpecifier("typebox/type", moduleCondition);
 	const ext = typePath.slice(typePath.lastIndexOf("."));
 	const leafDir = (0, node_path.join)((0, node_path.dirname)(typePath), "elysia");
 	const typebox = await import((0, node_url.pathToFileURL)(typeboxPath).href);
@@ -316,13 +380,6 @@ async function generateVirtualType(typeSpecifier = "elysia/type") {
 	return source;
 }
 const _importedEntries = /* @__PURE__ */ new Set();
-let activeGenerationWorkers = 0;
-let lastGenerationWorkerExit;
-/** @internal Test diagnostic for deterministic worker cleanup. */
-const getAotWorkerDiagnostics = () => ({
-	activeWorkers: activeGenerationWorkers,
-	lastExit: lastGenerationWorkerExit
-});
 /**
 * Extension mirroring the running module's own build output, so a sibling
 * source file can be resolved from `import.meta.url` in `.mjs`/`.js`/`.ts`
@@ -336,16 +393,15 @@ const workerUrl = () => {
 	return new URL("./worker" + siblingModuleExt(moduleUrl), moduleUrl);
 };
 /** @internal Re-evaluate an entry in a disposable worker for watch rebuilds. */
-async function generateCompiledArtifactsIsolated(file, options) {
+async function generateCompiledArtifactsIsolated(file, options, moduleCondition = resolveEntryModuleKind(file)) {
 	const entry = resolveEntry(file);
 	console.warn("[elysia-aot] re-evaluating \"" + entry + "\" in an isolated worker for rebuild. Top-level side effects run only inside the worker.");
 	const worker = new node_worker_threads.Worker(workerUrl(), { workerData: {
 		file: entry,
-		options
+		options,
+		moduleCondition
 	} });
-	activeGenerationWorkers++;
 	const exit = new Promise((resolve) => worker.once("exit", resolve));
-	lastGenerationWorkerExit = exit;
 	try {
 		return await new Promise((resolve, reject) => {
 			let received = false;
@@ -367,19 +423,34 @@ async function generateCompiledArtifactsIsolated(file, options) {
 			await worker.terminate();
 		} finally {
 			await exit;
-			activeGenerationWorkers--;
 		}
 	}
 }
-function isStandardResponse(response) {
-	if (response == null || typeof response !== "object") return false;
-	if (require_compile_handler_frozen_validator.isStandardSchema(response)) return true;
-	if ("~kind" in response || "~elyAcl" in response) return false;
-	const entries = Object.values(response);
-	if (entries.length === 0) return false;
-	return entries.every((v) => require_compile_handler_frozen_validator.isStandardSchema(v));
+const validatorSlotKey = ({ method, path, slot }) => `${method}\0${path}\0${slot}`;
+/** @internal Exact logical-slot gate used by AOT mode selection. */
+function validatorSlotSetsMatch(expected, captured) {
+	const expectedKeys = new Set(expected.map(validatorSlotKey));
+	const capturedKeys = new Set(captured.map(validatorSlotKey));
+	if (expectedKeys.size !== capturedKeys.size) return false;
+	for (const key of expectedKeys) if (!capturedKeys.has(key)) return false;
+	return true;
 }
-async function generateCompiledArtifacts(file, options) {
+/**
+* The manifest is one flat `method -> path` table with no per-app namespace,
+* bound to whichever app builds a router first, so a mounted sub-app (a second
+* Elysia building on its own schedule) is not representable
+*
+* refuse at build time rather than ship a coin flip
+*/
+const assertNoMount = (app, entry) => {
+	const routes = app["~routes"];
+	const mounted = [];
+	for (const route of routes) if (route[2]?.["~mount"] && !mounted.includes(route[1])) mounted.push(route[1]);
+	if (!mounted.length) return;
+	throw new Error(`[elysia-aot] "${entry}" mounts a sub-app (${mounted.join(", ")}). AOT cannot compile a mounted sub-app. Compose with .use() instead of .mount(), or disable AOT plugin`);
+};
+async function generateCompiledArtifacts(file, options, moduleCondition = resolveEntryModuleKind(file)) {
+	if (moduleCondition !== loadedModuleCondition) throw new Error(`[elysia-aot] entry uses the ${moduleCondition === "cjs" ? "CommonJS \"require\"" : "ESM \"import\""} package condition, but the AOT build plugin was loaded through ${loadedModuleCondition === "cjs" ? "CommonJS \"require\"" : "ESM \"import\""}; entry: ${JSON.stringify(resolveEntry(file))}. Load the plugin through ${moduleCondition === "cjs" ? "require()" : "import"} so capture and generated registration share one Elysia module instance.`);
 	const previousAotBuild = process.env.ELYSIA_AOT_BUILD;
 	process.env.ELYSIA_AOT_BUILD = "1";
 	const previousAotVerbose = process.env.ELYSIA_AOT_VERBOSE;
@@ -388,14 +459,15 @@ async function generateCompiledArtifacts(file, options) {
 	try {
 		const entry = resolveEntry(file);
 		const entryReal = realPath(entry);
-		if (_importedEntries.has(entryReal)) return generateCompiledArtifactsIsolated(file, options);
+		if (_importedEntries.has(entryReal)) return generateCompiledArtifactsIsolated(file, options, moduleCondition);
 		_importedEntries.add(entryReal);
 		const mod = await import(entry);
 		const app = mod.app ?? mod.default;
 		if (!app || typeof app.compile !== "function") throw new Error(`[elysia-aot] "${entry}" must export an Elysia app`);
 		const typedApp = app;
+		assertNoMount(typedApp, entry);
 		const sourceOptions = {
-			register: true,
+			moduleCondition,
 			registerFrom: options?.registerFrom,
 			reconstructFrom: options?.reconstructFrom,
 			lazy: options?.lazy,
@@ -404,10 +476,13 @@ async function generateCompiledArtifacts(file, options) {
 		const strip = options?.strip ?? "auto";
 		const adapterStub = options?.target === "bun" ? "bun" : options?.target === "node" || options?.target === "workerd" ? "web-standard" : false;
 		const productionStub = options?.production !== false;
+		const exactMirror = resolveExactMirror(entry);
 		if (strip === false) return {
 			source: await require_plugin_aot_source.compileToSource(typedApp, sourceOptions),
 			stub: {
 				...NO_STUB,
+				typeboxValue: true,
+				exactMirror,
 				adapter: adapterStub,
 				isProduction: productionStub
 			},
@@ -417,32 +492,51 @@ async function generateCompiledArtifacts(file, options) {
 		const report = require_plugin_aot_source.replayStubbability(typedApp, artifacts.handlers);
 		const aliases = /* @__PURE__ */ new Set();
 		for (const handler of artifacts.handlers) if (handler.alias) for (const name of handler.alias.split(",")) aliases.add(name);
-		const hasWS = !!typedApp["~hasWS"] || !!typedApp["~routes"]?.some((route) => route?.[0] === "WS");
-		const history = typedApp["~routes"] ?? [];
+		const history = typedApp["~routes"];
+		const hasWS = !!typedApp["~hasWS"] || history.some((route) => route[0] === "WS");
 		const mayTrace = !!typedApp["~hasTrace"] || history.some((route) => (route?.[4])?.trace?.length || route?.[2]?.["~mount"]);
-		let expectedSlots = 0;
+		const expectedSlots = [];
+		const declaredTypeBoxSlots = /* @__PURE__ */ new Set();
 		let routesForbidSeal = false;
+		let wsCookie = false;
 		for (const route of history) {
+			const method = route[0];
+			const path = route[1];
+			const expectTypeBoxSlot = (slot) => {
+				const identity = {
+					method,
+					path,
+					slot
+				};
+				const key = validatorSlotKey(identity);
+				if (declaredTypeBoxSlots.has(key)) routesForbidSeal = true;
+				else {
+					declaredTypeBoxSlots.add(key);
+					expectedSlots.push(identity);
+				}
+			};
 			const [, , , instance, hook, appHook, inheritedChain, macroScope] = route;
 			const hooks = require_compile_handler_index.composeRouteHook(instance, hook, appHook, inheritedChain, typedApp, macroScope);
+			if (method === "WS" && (hook?.cookie !== void 0 || hooks?.cookie !== void 0)) wsCookie = true;
 			if (!hooks) continue;
 			let routeHasTypeBoxDirectSlot = false;
-			for (const slot of [
-				"body",
-				"query",
-				"params",
-				"headers",
-				"cookie"
-			]) {
-				const value = hooks[slot];
-				if (value === void 0) continue;
-				if (require_compile_handler_frozen_validator.isStandardSchema(value)) continue;
+			const classify = (schema, slot) => {
+				if (schema === void 0) {
+					routesForbidSeal = true;
+					return;
+				}
+				if (require_compile_handler_frozen_validator.isStandardSchema(schema)) return;
 				routeHasTypeBoxDirectSlot = true;
-				expectedSlots++;
+				expectTypeBoxSlot(slot);
+			};
+			for (const slot of require_compile_handler_frozen_validator.REQUEST_SLOTS) {
+				const value = hooks[slot];
+				if (value !== void 0) classify(require_compile_handler_frozen_validator.resolveModelRef(value, typedApp), slot);
 			}
-			if (hooks.response !== void 0 && !isStandardResponse(hooks.response)) {
-				routeHasTypeBoxDirectSlot = true;
-				expectedSlots++;
+			if (hooks.response !== void 0) {
+				const response = require_compile_handler_frozen_validator.resolveModelRef(hooks.response, typedApp);
+				if (require_compile_handler_frozen_validator.isResponseMap(response)) for (const status in response) classify(require_compile_handler_frozen_validator.resolveModelRef(response[status], typedApp), `response:${status}`);
+				else classify(response, "response:200");
 			}
 			const mergeSchemas = hooks.schemas;
 			if (Array.isArray(mergeSchemas) && mergeSchemas.length > 0) {
@@ -450,13 +544,13 @@ async function generateCompiledArtifacts(file, options) {
 			}
 		}
 		if (typedApp["~config"]?.normalize === "typebox") routesForbidSeal = true;
-		const frozenSlots = artifacts.validators.length;
-		const { plan: stub, mode } = planFromReport(strip, report, hasWS, mayTrace, aliases, (artifacts.handlers.length > 0 || artifacts.validators.length > 0) && !routesForbidSeal && frozenSlots === expectedSlots && artifacts.validators.every((v) => v.bridgeFree === true), artifacts.handlers.length === 0 && artifacts.validators.length === 0, adapterStub, productionStub);
+		const validatorSlotsMatch = validatorSlotSetsMatch(expectedSlots, artifacts.validators);
+		const { plan: stub, mode } = planFromReport(strip, report, hasWS, mayTrace, aliases, (artifacts.handlers.some((h) => h.code) || artifacts.validators.length > 0) && !routesForbidSeal && validatorSlotsMatch && artifacts.validators.every((v) => v.bridgeFree === true), !artifacts.handlers.some((h) => h.code) && artifacts.validators.length === 0, adapterStub, productionStub, wsCookie, exactMirror);
 		if (options?.target === "workerd") {
 			if (!report.jit) throw new Error(`[elysia-aot] target 'workerd' but handler JIT is still reachable (${report.reasons.join(", ") || "unknown"}). Every route must be captured into the AOT manifest.`);
-			if (frozenSlots !== expectedSlots) console.warn(`[elysia-aot] target 'workerd': only ${frozenSlots}/${expectedSlots} validator slots were frozen unfrozen slots compile at runtime and will fail on workerd.`);
+			if (!validatorSlotsMatch) console.warn("[elysia-aot] target 'workerd': captured validator slots do not exactly match declared slots; unfrozen slots compile at runtime and will fail on workerd.");
 		}
-		const virtualType = mode === "off" ? void 0 : await generateVirtualType("elysia/type");
+		const virtualType = mode === "off" ? void 0 : await generateVirtualType(moduleCondition);
 		return {
 			source: artifacts.source,
 			stub,
@@ -483,23 +577,28 @@ const realPath = (path) => {
 exports.ADAPTER_BUN_FILTER = ADAPTER_BUN_FILTER;
 exports.ADAPTER_CONSTANTS_FILTER = ADAPTER_CONSTANTS_FILTER;
 exports.ELYSIA_MODULE_FILTER = ELYSIA_MODULE_FILTER;
+exports.EXACT_MIRROR_REQUIRE_FILTER = EXACT_MIRROR_REQUIRE_FILTER;
 exports.IS_PRODUCTION_FILTER = IS_PRODUCTION_FILTER;
 exports.NO_STUB = NO_STUB;
 exports.OVERRIDE_MAP = OVERRIDE_MAP;
 exports.SOURCE_REGEX = SOURCE_REGEX;
 exports.STUB_SOURCES = STUB_SOURCES;
+exports.TYPEBOX_REQUIRE_FILTER = TYPEBOX_REQUIRE_FILTER;
+exports.TYPEBOX_SYSTEM_LITE_FILTER = TYPEBOX_SYSTEM_LITE_FILTER;
+exports.TYPEBOX_TYPE_FILTER = TYPEBOX_TYPE_FILTER;
 exports.adapterConstantsSource = adapterConstantsSource;
 exports.alignStubExtensions = alignStubExtensions;
 exports.bunAdapterStubSource = bunAdapterStubSource;
 exports.generateCompiledArtifacts = generateCompiledArtifacts;
 exports.generateCompiledArtifactsIsolated = generateCompiledArtifactsIsolated;
 exports.generateVirtualType = generateVirtualType;
-exports.getAotWorkerDiagnostics = getAotWorkerDiagnostics;
-exports.makeElysiaModuleFilterRegex = makeElysiaModuleFilterRegex;
 exports.makeIsElysiaModule = makeIsElysiaModule;
 exports.planFromReport = planFromReport;
 exports.realPath = realPath;
 exports.resolveElysiaRoot = resolveElysiaRoot;
 exports.resolveEntry = resolveEntry;
+exports.resolveEntryModuleKind = resolveEntryModuleKind;
+exports.resolveExactMirror = resolveExactMirror;
 exports.rewriteIsProductionCalls = rewriteIsProductionCalls;
-exports.siblingModuleExt = siblingModuleExt;
+exports.siblingModuleExt = siblingModuleExt;
+exports.validatorSlotSetsMatch = validatorSlotSetsMatch;