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

package/dist/plugin/aot/core.mjs

@@ -1,10 +1,10 @@
-import { isStandardSchema, mergeSchemasAllStandard } from "../../compile/handler/frozen-validator.mjs";
+import { REQUEST_SLOTS, isResponseMap, isStandardSchema, mergeSchemasAllStandard, resolveModelRef } from "../../compile/handler/frozen-validator.mjs";
 import { composeRouteHook } from "../../compile/handler/index.mjs";
 import { captureArtifacts, compileToSource, replayStubbability } from "./source.mjs";
 import { createRequire } from "node:module";
-import { existsSync, realpathSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { pathToFileURL } from "node:url";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { dirname, extname, join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { Worker } from "node:worker_threads";
 
 //#region src/plugin/aot/core.ts
@@ -18,8 +18,31 @@ function findPackageRoot(from = process.cwd()) {
 	return dir;
 }
 const resolveEntry = (entry) => resolve(findPackageRoot(), entry);
+/** @internal Resolve the package condition used to evaluate an AOT entry. */
+const resolveEntryModuleKind = (entry) => {
+	const entryPath = resolveEntry(entry);
+	switch (extname(entryPath)) {
+		case ".cjs":
+		case ".cts": return "cjs";
+		case ".mjs":
+		case ".mts":
+		case ".ts":
+		case ".tsx": return "esm";
+		case ".js":
+		case ".jsx": {
+			const packagePath = join(findPackageRoot(dirname(entryPath)), "package.json");
+			if (!existsSync(packagePath)) return "cjs";
+			const pkg = JSON.parse(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,
@@ -27,6 +50,8 @@ const NO_STUB = {
 	sucrose: false,
 	compat: false,
 	bridge: false,
+	typeboxValue: false,
+	exactMirror: false,
 	adapter: false,
 	isProduction: false
 };
@@ -47,20 +72,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
 		},
@@ -71,71 +99,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 dirname(createRequire(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 {
+		createRequire(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)$/,
@@ -145,13 +150,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"
@@ -159,9 +171,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)$/,
@@ -170,11 +179,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 = {
@@ -202,6 +223,10 @@ const OVERRIDE_MAP = {
 		leaf: "boolean-string",
 		export: "BooleanString"
 	},
+	Composite: {
+		leaf: "keep-config",
+		export: "CompositeType"
+	},
 	Cookie: {
 		leaf: "cookie",
 		export: "Cookie"
@@ -210,6 +235,10 @@ const OVERRIDE_MAP = {
 		leaf: "date",
 		export: "DateType"
 	},
+	Evaluate: {
+		leaf: "keep-config",
+		export: "EvaluateType"
+	},
 	File: {
 		leaf: "file",
 		export: "File"
@@ -230,10 +259,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"
@@ -266,10 +303,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"
@@ -288,17 +349,20 @@ const OVERRIDE_MAP = {
 	}
 };
 const requireFromHere = createRequire(import.meta.url);
-const resolveSpecifier = (specifier) => {
-	const meta = import.meta;
-	if (typeof meta.resolve === "function") {
-		const url = meta.resolve(specifier);
-		return url.startsWith("file://") ? new URL(url).pathname : url;
+const moduleMeta = import.meta;
+const loadedModuleCondition = import.meta.url.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://") ? 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 = join(dirname(typePath), "elysia");
 	const typebox = await import(pathToFileURL(typeboxPath).href);
@@ -314,13 +378,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`
@@ -334,16 +391,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 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;
@@ -365,19 +421,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 (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) => 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;
@@ -386,14 +457,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,
@@ -402,10 +474,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 compileToSource(typedApp, sourceOptions),
 			stub: {
 				...NO_STUB,
+				typeboxValue: true,
+				exactMirror,
 				adapter: adapterStub,
 				isProduction: productionStub
 			},
@@ -415,32 +490,51 @@ async function generateCompiledArtifacts(file, options) {
 		const report = 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 = 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 (isStandardSchema(value)) continue;
+			const classify = (schema, slot) => {
+				if (schema === void 0) {
+					routesForbidSeal = true;
+					return;
+				}
+				if (isStandardSchema(schema)) return;
 				routeHasTypeBoxDirectSlot = true;
-				expectedSlots++;
+				expectTypeBoxSlot(slot);
+			};
+			for (const slot of REQUEST_SLOTS) {
+				const value = hooks[slot];
+				if (value !== void 0) classify(resolveModelRef(value, typedApp), slot);
 			}
-			if (hooks.response !== void 0 && !isStandardResponse(hooks.response)) {
-				routeHasTypeBoxDirectSlot = true;
-				expectedSlots++;
+			if (hooks.response !== void 0) {
+				const response = resolveModelRef(hooks.response, typedApp);
+				if (isResponseMap(response)) for (const status in response) classify(resolveModelRef(response[status], typedApp), `response:${status}`);
+				else classify(response, "response:200");
 			}
 			const mergeSchemas = hooks.schemas;
 			if (Array.isArray(mergeSchemas) && mergeSchemas.length > 0) {
@@ -448,13 +542,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,
@@ -478,4 +572,4 @@ const realPath = (path) => {
 };
 
 //#endregion
-export { ADAPTER_BUN_FILTER, ADAPTER_CONSTANTS_FILTER, ELYSIA_MODULE_FILTER, IS_PRODUCTION_FILTER, NO_STUB, OVERRIDE_MAP, SOURCE_REGEX, STUB_SOURCES, adapterConstantsSource, alignStubExtensions, bunAdapterStubSource, generateCompiledArtifacts, generateCompiledArtifactsIsolated, generateVirtualType, getAotWorkerDiagnostics, makeElysiaModuleFilterRegex, makeIsElysiaModule, planFromReport, realPath, resolveElysiaRoot, resolveEntry, rewriteIsProductionCalls, siblingModuleExt };
+export { ADAPTER_BUN_FILTER, ADAPTER_CONSTANTS_FILTER, ELYSIA_MODULE_FILTER, EXACT_MIRROR_REQUIRE_FILTER, IS_PRODUCTION_FILTER, NO_STUB, OVERRIDE_MAP, SOURCE_REGEX, STUB_SOURCES, TYPEBOX_REQUIRE_FILTER, TYPEBOX_SYSTEM_LITE_FILTER, TYPEBOX_TYPE_FILTER, adapterConstantsSource, alignStubExtensions, bunAdapterStubSource, generateCompiledArtifacts, generateCompiledArtifactsIsolated, generateVirtualType, makeIsElysiaModule, planFromReport, realPath, resolveElysiaRoot, resolveEntry, resolveEntryModuleKind, resolveExactMirror, rewriteIsProductionCalls, siblingModuleExt, validatorSlotSetsMatch };

package/dist/plugin/aot/esbuild.js

@@ -28,7 +28,11 @@ let node_fs_promises = require("node:fs/promises");
 const aot = (entry, options) => ({
 	name: "elysia-aot",
 	async setup(build) {
-		const hooks = require_plugin_aot_hooks.createAotPluginHooks(entry, options);
+		const entryPath = require_plugin_aot_core.resolveEntry(entry);
+		const moduleCondition = require_plugin_aot_core.resolveEntryModuleKind(entryPath);
+		if (build.initialOptions?.conditions?.includes("types")) throw new Error("[elysia-aot] esbuild conditions includes 'types'; this selects declaration files as runtime inputs. Remove the conflicting condition.");
+		if (moduleCondition === "cjs" && build.initialOptions?.conditions?.includes("import")) throw new Error("[elysia-aot] esbuild conditions includes 'import' for a CommonJS entry; this would load two Elysia module instances. Remove the conflicting condition.");
+		const hooks = require_plugin_aot_hooks.createAotPluginHooks(entry, options, moduleCondition);
 		let initial = true;
 		build.onStart(async () => {
 			if (initial) {
@@ -37,10 +41,9 @@ const aot = (entry, options) => ({
 			}
 			await hooks.buildStart();
 		});
-		await require_plugin_aot_hooks.setupAotOnLoad(build, hooks, {
-			readText: (path) => (0, node_fs_promises.readFile)(path, "utf8"),
-			resolveDir: (0, node_path.dirname)(require_plugin_aot_core.resolveEntry(entry))
-		});
+		await require_plugin_aot_hooks.setupAotOnLoad(build, hooks, (path) => (0, node_fs_promises.readFile)(path, "utf8"), (0, node_path.dirname)(entryPath));
+		const allowedKinds = moduleCondition === "cjs" ? new Set(["require-call", "require-resolve"]) : new Set(["import-statement", "dynamic-import"]);
+		build.onResolve({ filter: /^elysia(?:\/.*)?$/ }, (args) => allowedKinds.has(args.kind) ? void 0 : { errors: [{ text: `[elysia-aot] ${args.path} uses esbuild edge kind ${JSON.stringify(args.kind)}, which conflicts with the ${JSON.stringify(moduleCondition)} entry module condition. Use one consistent import/require condition for Elysia.` }] });
 	}
 });
 

package/dist/plugin/aot/esbuild.mjs

@@ -1,4 +1,4 @@
-import { resolveEntry } from "./core.mjs";
+import { resolveEntry, resolveEntryModuleKind } from "./core.mjs";
 import { createAotPluginHooks, setupAotOnLoad } from "./hooks.mjs";
 import { dirname } from "node:path";
 import { readFile } from "node:fs/promises";
@@ -26,7 +26,11 @@ import { readFile } from "node:fs/promises";
 const aot = (entry, options) => ({
 	name: "elysia-aot",
 	async setup(build) {
-		const hooks = createAotPluginHooks(entry, options);
+		const entryPath = resolveEntry(entry);
+		const moduleCondition = resolveEntryModuleKind(entryPath);
+		if (build.initialOptions?.conditions?.includes("types")) throw new Error("[elysia-aot] esbuild conditions includes 'types'; this selects declaration files as runtime inputs. Remove the conflicting condition.");
+		if (moduleCondition === "cjs" && build.initialOptions?.conditions?.includes("import")) throw new Error("[elysia-aot] esbuild conditions includes 'import' for a CommonJS entry; this would load two Elysia module instances. Remove the conflicting condition.");
+		const hooks = createAotPluginHooks(entry, options, moduleCondition);
 		let initial = true;
 		build.onStart(async () => {
 			if (initial) {
@@ -35,10 +39,9 @@ const aot = (entry, options) => ({
 			}
 			await hooks.buildStart();
 		});
-		await setupAotOnLoad(build, hooks, {
-			readText: (path) => readFile(path, "utf8"),
-			resolveDir: dirname(resolveEntry(entry))
-		});
+		await setupAotOnLoad(build, hooks, (path) => readFile(path, "utf8"), dirname(entryPath));
+		const allowedKinds = moduleCondition === "cjs" ? new Set(["require-call", "require-resolve"]) : new Set(["import-statement", "dynamic-import"]);
+		build.onResolve({ filter: /^elysia(?:\/.*)?$/ }, (args) => allowedKinds.has(args.kind) ? void 0 : { errors: [{ text: `[elysia-aot] ${args.path} uses esbuild edge kind ${JSON.stringify(args.kind)}, which conflicts with the ${JSON.stringify(moduleCondition)} entry module condition. Use one consistent import/require condition for Elysia.` }] });
 	}
 });
 

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

@@ -1,3 +1,4 @@
+import { AotModuleCondition } from "./source.js";
 import { ElysiaAotOptions } from "./core.js";
 
 //#region src/plugin/aot/hooks.d.ts
@@ -6,23 +7,11 @@ interface AotPluginHooks {
   buildEnd(): void;
   resolveId(id: string): string | undefined;
   load(id: string): string | undefined;
-  transform(code: string, id: string): string | undefined | Promise<string | undefined>;
+  transform(code: string, id: string): string | undefined;
   isTransformCandidate(id: string): boolean;
 }
-declare const createAotPluginHooks: (entry: string, options?: ElysiaAotOptions) => AotPluginHooks;
-interface AotOnLoadAdapterOptions {
-  /** Read a file's UTF-8 text (abstracted so Bun and esbuild can supply their own reader). */
-  readText: (path: string) => Promise<string>;
-  /**
-   * resolveDir for the manifest/virtual-type module loads.
-   * esbuild needs `dirname(entryPath)` so relative imports in the manifest
-   * resolve correctly; Bun does not use it (pass undefined for Bun).
-   */
-  resolveDir?: string;
-}
-declare function setupAotOnLoad(build: any, hooks: AotPluginHooks, {
-  readText,
-  resolveDir
-}: AotOnLoadAdapterOptions): Promise<void>;
+declare const createAotPluginHooks: (entry: string, options?: ElysiaAotOptions, moduleCondition?: AotModuleCondition) => AotPluginHooks;
+declare const createTypeboxWiringHooks: () => AotPluginHooks;
+declare function setupAotOnLoad(build: any, hooks: AotPluginHooks, readText: (path: string) => Promise<string>, resolveDir?: string): Promise<void>;
 //#endregion
-export { AotOnLoadAdapterOptions, AotPluginHooks, createAotPluginHooks, setupAotOnLoad };
+export { AotPluginHooks, createAotPluginHooks, createTypeboxWiringHooks, setupAotOnLoad };