elysia 2.0.0-exp.2 → 2.0.0-exp.21

package/dist/plugin/core.mjs

@@ -1,4 +1,4 @@
-import { compileToSource } from "./source.mjs";
+import { captureArtifacts, compileToSource, replayStubbability } from "./source.mjs";
 import { existsSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 
@@ -18,19 +18,97 @@ function resolveLoader(entryPath) {
 	return ext === ".js" || ext === ".mjs" || ext === ".cjs" ? "js" : ext === ".jsx" ? "jsx" : ext === ".tsx" ? "tsx" : "ts";
 }
 const entryFilter = (entryPath) => new RegExp("^" + entryPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") + "$");
+const NO_STUB = {
+	jit: false,
+	ws: false,
+	reconstruct: false,
+	cookie: false,
+	trace: false,
+	sucrose: false
+};
+/**
+* Resolve whether handler JIT is safe to stub for `entry`, honouring the
+* `strip` option. `'auto'` stubs only when detection proves handler JIT unused;
+* `true` throws when handler JIT is still reachable; `false` disables.
+*/
+function planFromReport(strip, report, hasWS, aliases) {
+	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.`);
+	return {
+		jit,
+		ws: !hasWS,
+		reconstruct: jit && !aliases.has("va") && !aliases.has("cc") && !aliases.has("tr"),
+		cookie: jit && !aliases.has("cc"),
+		trace: jit && !aliases.has("tr"),
+		sucrose: jit
+	};
+}
+const STUB_SOURCES = {
+	jit: [{
+		filter: /[\\/]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 setCaptureHeaderShorthand(){}\n"
+	}],
+	ws: [{
+		filter: /[\\/]ws[\\/]route\.(m?js|ts)$/,
+		source: "const e=()=>{throw new Error(\"[elysia-aot] WebSocket route builder was stripped (strip mode) but a WS route was used. Rebuild with strip:false.\")}\nexport function buildWSRoute(){return e()}\nexport function buildGlobalWSHandler(){return e()}\n"
+	}],
+	reconstruct: [{
+		filter: /[\\/]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: /[\\/]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 function createCookieJar(){return e()}\nexport function parseCookie(){return e()}\nexport function parseCookieRaw(){return e()}\nexport function parseCookieRawSync(){return e()}\nexport function buildCookieJar(){return e()}\nexport function signCookieValues(){return e()}\nexport function signCookie(){return e()}\nexport function unsignCookie(){return e()}\n"
+	}, {
+		filter: /[\\/]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"
+	}],
+	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()}\n"
+	}],
+	sucrose: [{
+		filter: /[\\/]elysia[\\/](dist|src)[\\/]memory\.(m?js|ts)$/,
+		source: "import { clearContextCache } from './context'\nimport { isBun } from './universal/constants'\nimport { Validator } from './validator'\nexport function flushMemory() {\n	clearContextCache()\n	Validator.clear()\n	if (isBun) Bun.gc()\n	else if (typeof global?.gc === 'function') global.gc()\n}\n"
+	}]
+};
 async function generateCompiledModule(file, options) {
+	return (await generateCompiledArtifacts(file, options)).source;
+}
+async function generateCompiledArtifacts(file, options) {
+	const previousAotBuild = process.env.ELYSIA_AOT_BUILD;
 	process.env.ELYSIA_AOT_BUILD = "1";
-	const entry = resolveEntry(file);
-	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`);
-	return compileToSource(app, {
-		register: true,
-		registerFrom: options?.registerFrom,
-		lazy: options?.lazy,
-		target: options?.target
-	});
+	try {
+		const entry = resolveEntry(file);
+		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;
+		const sourceOptions = {
+			register: true,
+			registerFrom: options?.registerFrom,
+			lazy: options?.lazy,
+			target: options?.target
+		};
+		const strip = options?.strip ?? "auto";
+		if (strip === false) return {
+			source: await compileToSource(typedApp, sourceOptions),
+			stub: NO_STUB
+		};
+		const artifacts = await captureArtifacts(typedApp, sourceOptions);
+		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.history?.some((route) => route?.[0] === "WS");
+		return {
+			source: artifacts.source,
+			stub: planFromReport(strip, report, hasWS, aliases)
+		};
+	} finally {
+		if (previousAotBuild === void 0) delete process.env.ELYSIA_AOT_BUILD;
+		else process.env.ELYSIA_AOT_BUILD = previousAotBuild;
+	}
 }
 
 //#endregion
-export { entryFilter, generateCompiledModule, resolveEntry, resolveLoader };
+export { STUB_SOURCES, entryFilter, generateCompiledArtifacts, generateCompiledModule, resolveEntry, resolveLoader };

package/dist/plugin/esbuild.d.ts

@@ -16,7 +16,17 @@ import { ElysiaAotOptions } from "./core.js";
  *   outfile: 'dist/index.js',
  *   plugins: [elysiaAot('src/index.ts')]
  * })
+ *
+ * process.exit(0)
  * ```
+ *
+ * The plugin imports your entry to capture the compiled app, running its
+ * top-level code. `.listen()` is auto-skipped during build (gated on
+ * `ELYSIA_AOT_BUILD`), but any other import-time handle — a DB pool,
+ * `setInterval`, a queue consumer — keeps the process alive after the bundle
+ * is written. End the build script with `process.exit(0)` (the bundle is
+ * already on disk), or gate the side effect with
+ * `if (!process.env.ELYSIA_AOT_BUILD)`.
  */
 declare const aot: (entry: string, options?: ElysiaAotOptions) => {
   name: string;

package/dist/plugin/esbuild.js

@@ -30,12 +30,22 @@ const realPath = (path) => {
 *   outfile: 'dist/index.js',
 *   plugins: [elysiaAot('src/index.ts')]
 * })
+*
+* process.exit(0)
 * ```
+*
+* The plugin imports your entry to capture the compiled app, running its
+* top-level code. `.listen()` is auto-skipped during build (gated on
+* `ELYSIA_AOT_BUILD`), but any other import-time handle — a DB pool,
+* `setInterval`, a queue consumer — keeps the process alive after the bundle
+* is written. End the build script with `process.exit(0)` (the bundle is
+* already on disk), or gate the side effect with
+* `if (!process.env.ELYSIA_AOT_BUILD)`.
 */
 const aot = (entry, options) => ({
 	name: "elysia-aot",
 	async setup(build) {
-		const source = await require_plugin_core.generateCompiledModule(entry, options);
+		const { source, stub } = await require_plugin_core.generateCompiledArtifacts(entry, options);
 		const entryPath = require_plugin_core.resolveEntry(entry);
 		const entryReal = realPath(entryPath);
 		const treeShake = options?.treeShake ?? true;
@@ -52,6 +62,13 @@ const aot = (entry, options) => ({
 			loader: "js",
 			resolveDir: (0, node_path.dirname)(entryPath)
 		}));
+		for (const key of Object.keys(require_plugin_core.STUB_SOURCES)) {
+			if (!stub[key]) continue;
+			for (const { filter, source: stubSource } of require_plugin_core.STUB_SOURCES[key]) build.onLoad({ filter }, () => ({
+				contents: stubSource,
+				loader: "js"
+			}));
+		}
 		if (treeShake) build.onLoad({ filter: SOURCE }, async (args) => {
 			const isEntryFile = isEntry(args.path);
 			const inModules = args.path.includes("/node_modules/");

package/dist/plugin/esbuild.mjs

@@ -1,4 +1,4 @@
-import { entryFilter, generateCompiledModule, resolveEntry, resolveLoader } from "./core.mjs";
+import { STUB_SOURCES, entryFilter, generateCompiledArtifacts, resolveEntry, resolveLoader } from "./core.mjs";
 import { rewriteTypeImport } from "./treeshake.mjs";
 import { realpathSync } from "node:fs";
 import { dirname } from "node:path";
@@ -28,12 +28,22 @@ const realPath = (path) => {
 *   outfile: 'dist/index.js',
 *   plugins: [elysiaAot('src/index.ts')]
 * })
+*
+* process.exit(0)
 * ```
+*
+* The plugin imports your entry to capture the compiled app, running its
+* top-level code. `.listen()` is auto-skipped during build (gated on
+* `ELYSIA_AOT_BUILD`), but any other import-time handle — a DB pool,
+* `setInterval`, a queue consumer — keeps the process alive after the bundle
+* is written. End the build script with `process.exit(0)` (the bundle is
+* already on disk), or gate the side effect with
+* `if (!process.env.ELYSIA_AOT_BUILD)`.
 */
 const aot = (entry, options) => ({
 	name: "elysia-aot",
 	async setup(build) {
-		const source = await generateCompiledModule(entry, options);
+		const { source, stub } = await generateCompiledArtifacts(entry, options);
 		const entryPath = resolveEntry(entry);
 		const entryReal = realPath(entryPath);
 		const treeShake = options?.treeShake ?? true;
@@ -50,6 +60,13 @@ const aot = (entry, options) => ({
 			loader: "js",
 			resolveDir: dirname(entryPath)
 		}));
+		for (const key of Object.keys(STUB_SOURCES)) {
+			if (!stub[key]) continue;
+			for (const { filter, source: stubSource } of STUB_SOURCES[key]) build.onLoad({ filter }, () => ({
+				contents: stubSource,
+				loader: "js"
+			}));
+		}
 		if (treeShake) build.onLoad({ filter: SOURCE }, async (args) => {
 			const isEntryFile = isEntry(args.path);
 			const inModules = args.path.includes("/node_modules/");

package/dist/plugin/source.d.ts

@@ -1,4 +1,6 @@
+import { CapturedHandler, CapturedValidator } from "../compile/aot.js";
 import { AnyElysia } from "../base.js";
+import { JITProbeReason } from "../compile/jit-probe.js";
 
 //#region src/plugin/source.d.ts
 type AotTarget = 'bun' | 'node' | 'workerd';
@@ -34,5 +36,40 @@ interface CompileToSourceOptions {
 }
 declare const autoGroupSize: (routes: number) => number;
 declare function compileToSource(app: AnyElysia, options?: CompileToSourceOptions): Promise<string>;
+interface CapturedArtifacts {
+  source: string;
+  validators: CapturedValidator[];
+  handlers: CapturedHandler[];
+}
+declare function captureArtifacts(app: AnyElysia, options?: CompileToSourceOptions): Promise<CapturedArtifacts>;
+interface StubbabilityReport {
+  /** Handler JIT is provably unused → handler-only strip is safe. */
+  stubbable: boolean;
+  /** `sucrose` + the handler `new Function` codegen is unused. */
+  jit: boolean;
+  /** Why handler JIT cannot be stripped, if any. */
+  reasons: JITProbeReason[];
+}
+/**
+ * Decide whether the frozen build can run with handler JIT replaced by a
+ * throwing stub
+ *
+ * Static prediction is unsound
+ *
+ * eg. an inline-eligible handler (`() => 'ok'`) is never captured into
+ * handler manifest and falls through to `sucrose` at runtime
+ *
+ * So instead of guessing, this captures the manifest, registers it in-process
+ * and replays every route through the real `compileHandler` with a tripwire armed
+ *
+ * Handler JIT is only reported stubbable when no handler-JIT entry point was reached
+ */
+declare function analyzeStubbability(app: AnyElysia, options?: CompileToSourceOptions): Promise<StubbabilityReport>;
+/**
+ * Replay a frozen build from already-captured artifacts (no second capture) and
+ * report whether handler JIT was reached. Shared by `analyzeStubbability` and
+ * the single-capture build path.
+ */
+declare function replayStubbability(app: AnyElysia, handlers: CapturedHandler[]): StubbabilityReport;
 //#endregion
-export { AotTarget, CompileToSourceOptions, autoGroupSize, compileToSource };
+export { AotTarget, CapturedArtifacts, CompileToSourceOptions, StubbabilityReport, analyzeStubbability, autoGroupSize, captureArtifacts, compileToSource, replayStubbability };

package/dist/plugin/source.js

@@ -2,22 +2,102 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_utils = require('../utils.js');
 const require_universal_env = require('../universal/env.js');
 const require_compile_aot = require('../compile/aot.js');
+const require_validator_index = require('../validator/index.js');
+const require_compile_jit_probe = require('../compile/jit-probe.js');
+const require_compile_handler_jit = require('../compile/handler/jit.js');
 const require_compile_handler_index = require('../compile/handler/index.js');
 
 //#region src/plugin/source.ts
 const autoGroupSize = (routes) => routes < 64 ? 1 : routes < 256 ? 2 : routes < 2048 ? 4 : routes < 8192 ? 16 : 64;
 async function compileToSource(app, options) {
+	return (await captureArtifacts(app, options)).source;
+}
+async function captureArtifacts(app, options) {
+	const previousAotBuild = require_universal_env.env.ELYSIA_AOT_BUILD;
 	require_universal_env.env.ELYSIA_AOT_BUILD = "1";
-	if (!require_compile_aot.Capture.isCapturing()) throw new Error("[elysia-aot]: ELYSIA_AOT_BUILD=1 must be set to enable AOT capture mode");
-	require_compile_aot.beginValidatorCapture();
-	const modules = app.modules;
-	if (modules) await modules;
-	if (options?.target !== void 0) require_compile_handler_index.setCaptureHeaderShorthand(options.target === "bun");
 	try {
+		if (!require_compile_aot.Capture.isCapturing()) throw new Error("[elysia-aot]: ELYSIA_AOT_BUILD=1 must be set to enable AOT capture mode");
+		require_compile_aot.beginValidatorCapture();
+		const modules = app.modules;
+		if (modules) await modules;
+		if (options?.target !== void 0) require_compile_handler_jit.setCaptureHeaderShorthand(options.target === "bun");
 		app.compile();
-		return emitModule(require_compile_aot.endValidatorCapture(), require_compile_aot.endHandlerCapture(), options);
+		const captured = require_compile_aot.endValidatorCapture();
+		const handlers = require_compile_aot.endHandlerCapture();
+		return {
+			source: emitModule(captured, handlers, options),
+			validators: captured,
+			handlers
+		};
 	} finally {
-		require_compile_handler_index.setCaptureHeaderShorthand(void 0);
+		require_compile_handler_jit.setCaptureHeaderShorthand(void 0);
+		if (previousAotBuild === void 0) delete require_universal_env.env.ELYSIA_AOT_BUILD;
+		else require_universal_env.env.ELYSIA_AOT_BUILD = previousAotBuild;
+	}
+}
+/**
+* Decide whether the frozen build can run with handler JIT replaced by a
+* throwing stub
+*
+* Static prediction is unsound
+*
+* eg. an inline-eligible handler (`() => 'ok'`) is never captured into
+* handler manifest and falls through to `sucrose` at runtime
+*
+* So instead of guessing, this captures the manifest, registers it in-process
+* and replays every route through the real `compileHandler` with a tripwire armed
+*
+* Handler JIT is only reported stubbable when no handler-JIT entry point was reached
+*/
+async function analyzeStubbability(app, options) {
+	const { handlers } = await captureArtifacts(app, options);
+	return replayStubbability(app, handlers);
+}
+const materialiseHandlersForReplay = (captured) => {
+	const manifest = {};
+	for (const h of captured) (manifest[h.method] ??= {})[h.path] = {
+		a: h.alias ? h.alias.split(",") : [],
+		f: new Function(`return ${require_compile_aot.Source.handlerFactory(h.alias, h.code)}`)()
+	};
+	return manifest;
+};
+/**
+* Replay a frozen build from already-captured artifacts (no second capture) and
+* report whether handler JIT was reached. Shared by `analyzeStubbability` and
+* the single-capture build path.
+*/
+function replayStubbability(app, handlers) {
+	const previousCompiled = require_compile_aot.Compiled.snapshot();
+	const previousAotBuild = require_universal_env.env.ELYSIA_AOT_BUILD;
+	if (previousAotBuild !== void 0) delete require_universal_env.env.ELYSIA_AOT_BUILD;
+	try {
+		require_compile_aot.Compiled.clear();
+		require_compile_aot.Compiled.handlers = materialiseHandlersForReplay(handlers);
+		require_validator_index.Validator.clear();
+		const history = app.history ?? [];
+		require_compile_jit_probe.JITProbe.begin();
+		for (const route of history) try {
+			if (route[0] === "WS") {
+				require_compile_jit_probe.JITProbe.end();
+				return {
+					stubbable: false,
+					jit: false,
+					reasons: ["sucrose"]
+				};
+			} else require_compile_handler_index.compileHandler(route, app);
+		} catch {
+			require_compile_jit_probe.JITProbe.end();
+			return {
+				stubbable: false,
+				jit: false,
+				reasons: ["handler:new-function"]
+			};
+		}
+		return require_compile_jit_probe.JITProbe.end();
+	} finally {
+		require_compile_aot.Compiled.restore(previousCompiled);
+		require_validator_index.Validator.clear();
+		if (previousAotBuild !== void 0) require_universal_env.env.ELYSIA_AOT_BUILD = previousAotBuild;
 	}
 }
 function emitModule(captured, handlers, options) {
@@ -81,7 +161,10 @@ function emitModule(captured, handlers, options) {
 		if (c.precomputeSafe) {
 			parts.push("ps: 1");
 			if (c.precomputedDefault !== void 0) parts.push(`pd: ${JSON.stringify(c.precomputedDefault)}`);
+			if (c.precomputeNull) parts.push("pn: 1");
 			if (c.precomputedObjectDefault !== void 0) parts.push(`pod: ${JSON.stringify(c.precomputedObjectDefault)}`);
+			if (c.defaultCloner) parts.push(`dc: ${c.defaultCloner}`);
+			if (c.objectDefaultMerger) parts.push(`pm: ${c.objectDefaultMerger}`);
 		}
 		if (c.customErrors?.length) {
 			const ce = c.customErrors.map((e) => `{ p: ${JSON.stringify(e.path)}, c: ${require_compile_aot.Source.checkFactory(e.identifier, require_compile_aot.Source.checkCode(e.checkDefs, e.checkValue))}${e.external ? ", e: 1" : ""} }`).join(", ");
@@ -99,6 +182,7 @@ function emitModule(captured, handlers, options) {
 			}).join(", ");
 			parts.push(`ic: [${ic}]`);
 		}
+		if (c.coercePlan) parts.push(`cp: ${JSON.stringify(c.coercePlan)}`);
 		return parts;
 	};
 	const treeToSource = (tree, slotRef, sink) => {
@@ -248,16 +332,23 @@ function emitModule(captured, handlers, options) {
 	handlerExport += "}\n";
 	if (options?.register) handlerExport += "Compiled.handlers = handlers\n";
 	let body = "// Generated by Elysia build plugin. Do not edit.\n";
-	if (options?.register) body += `import { Compiled } from ${JSON.stringify(options.registerFrom ?? "elysia")}\nimport { CheckContext } from 'typebox/schema'
-import { Guard } from 'typebox/guard'
-import { Format } from 'typebox/format'
-import { Hashing } from 'typebox/system'
-`;
+	if (options?.register) {
+		body += `import { Compiled } from ${JSON.stringify(options.registerFrom ?? "elysia")}\n`;
+		const generated = branchDecls + unionDecls + validatorDecls + handlerDecls;
+		const needs = (symbol) => new RegExp(`\\b${symbol}\\b`).test(generated);
+		if (needs("CheckContext")) body += "import { CheckContext } from 'typebox/schema'\n";
+		if (needs("Guard")) body += "import { Guard } from 'typebox/guard'\n";
+		if (needs("Format")) body += "import { Format } from 'typebox/format'\n";
+		if (needs("Hashing")) body += "import { Hashing } from 'typebox/system'\n";
+	}
 	body += "\n" + branchDecls + (branchDecls && "\n") + unionDecls + (unionDecls && "\n") + validatorDecls + handlerDecls + "\n" + validatorExport + "\n" + handlerExport;
 	if (!lazy) body += "\nexport default validators\n";
 	return body;
 }
 
 //#endregion
+exports.analyzeStubbability = analyzeStubbability;
 exports.autoGroupSize = autoGroupSize;
-exports.compileToSource = compileToSource;
+exports.captureArtifacts = captureArtifacts;
+exports.compileToSource = compileToSource;
+exports.replayStubbability = replayStubbability;

package/dist/plugin/source.mjs

@@ -1,22 +1,102 @@
 import { nullObject } from "../utils.mjs";
 import { env } from "../universal/env.mjs";
-import { Capture, Source, beginValidatorCapture, endHandlerCapture, endValidatorCapture } from "../compile/aot.mjs";
-import { setCaptureHeaderShorthand } from "../compile/handler/index.mjs";
+import { Capture, Compiled, Source, beginValidatorCapture, endHandlerCapture, endValidatorCapture } from "../compile/aot.mjs";
+import { Validator } from "../validator/index.mjs";
+import { JITProbe } from "../compile/jit-probe.mjs";
+import { setCaptureHeaderShorthand } from "../compile/handler/jit.mjs";
+import { compileHandler } from "../compile/handler/index.mjs";
 
 //#region src/plugin/source.ts
 const autoGroupSize = (routes) => routes < 64 ? 1 : routes < 256 ? 2 : routes < 2048 ? 4 : routes < 8192 ? 16 : 64;
 async function compileToSource(app, options) {
+	return (await captureArtifacts(app, options)).source;
+}
+async function captureArtifacts(app, options) {
+	const previousAotBuild = env.ELYSIA_AOT_BUILD;
 	env.ELYSIA_AOT_BUILD = "1";
-	if (!Capture.isCapturing()) throw new Error("[elysia-aot]: ELYSIA_AOT_BUILD=1 must be set to enable AOT capture mode");
-	beginValidatorCapture();
-	const modules = app.modules;
-	if (modules) await modules;
-	if (options?.target !== void 0) setCaptureHeaderShorthand(options.target === "bun");
 	try {
+		if (!Capture.isCapturing()) throw new Error("[elysia-aot]: ELYSIA_AOT_BUILD=1 must be set to enable AOT capture mode");
+		beginValidatorCapture();
+		const modules = app.modules;
+		if (modules) await modules;
+		if (options?.target !== void 0) setCaptureHeaderShorthand(options.target === "bun");
 		app.compile();
-		return emitModule(endValidatorCapture(), endHandlerCapture(), options);
+		const captured = endValidatorCapture();
+		const handlers = endHandlerCapture();
+		return {
+			source: emitModule(captured, handlers, options),
+			validators: captured,
+			handlers
+		};
 	} finally {
 		setCaptureHeaderShorthand(void 0);
+		if (previousAotBuild === void 0) delete env.ELYSIA_AOT_BUILD;
+		else env.ELYSIA_AOT_BUILD = previousAotBuild;
+	}
+}
+/**
+* Decide whether the frozen build can run with handler JIT replaced by a
+* throwing stub
+*
+* Static prediction is unsound
+*
+* eg. an inline-eligible handler (`() => 'ok'`) is never captured into
+* handler manifest and falls through to `sucrose` at runtime
+*
+* So instead of guessing, this captures the manifest, registers it in-process
+* and replays every route through the real `compileHandler` with a tripwire armed
+*
+* Handler JIT is only reported stubbable when no handler-JIT entry point was reached
+*/
+async function analyzeStubbability(app, options) {
+	const { handlers } = await captureArtifacts(app, options);
+	return replayStubbability(app, handlers);
+}
+const materialiseHandlersForReplay = (captured) => {
+	const manifest = {};
+	for (const h of captured) (manifest[h.method] ??= {})[h.path] = {
+		a: h.alias ? h.alias.split(",") : [],
+		f: new Function(`return ${Source.handlerFactory(h.alias, h.code)}`)()
+	};
+	return manifest;
+};
+/**
+* Replay a frozen build from already-captured artifacts (no second capture) and
+* report whether handler JIT was reached. Shared by `analyzeStubbability` and
+* the single-capture build path.
+*/
+function replayStubbability(app, handlers) {
+	const previousCompiled = Compiled.snapshot();
+	const previousAotBuild = env.ELYSIA_AOT_BUILD;
+	if (previousAotBuild !== void 0) delete env.ELYSIA_AOT_BUILD;
+	try {
+		Compiled.clear();
+		Compiled.handlers = materialiseHandlersForReplay(handlers);
+		Validator.clear();
+		const history = app.history ?? [];
+		JITProbe.begin();
+		for (const route of history) try {
+			if (route[0] === "WS") {
+				JITProbe.end();
+				return {
+					stubbable: false,
+					jit: false,
+					reasons: ["sucrose"]
+				};
+			} else compileHandler(route, app);
+		} catch {
+			JITProbe.end();
+			return {
+				stubbable: false,
+				jit: false,
+				reasons: ["handler:new-function"]
+			};
+		}
+		return JITProbe.end();
+	} finally {
+		Compiled.restore(previousCompiled);
+		Validator.clear();
+		if (previousAotBuild !== void 0) env.ELYSIA_AOT_BUILD = previousAotBuild;
 	}
 }
 function emitModule(captured, handlers, options) {
@@ -80,7 +160,10 @@ function emitModule(captured, handlers, options) {
 		if (c.precomputeSafe) {
 			parts.push("ps: 1");
 			if (c.precomputedDefault !== void 0) parts.push(`pd: ${JSON.stringify(c.precomputedDefault)}`);
+			if (c.precomputeNull) parts.push("pn: 1");
 			if (c.precomputedObjectDefault !== void 0) parts.push(`pod: ${JSON.stringify(c.precomputedObjectDefault)}`);
+			if (c.defaultCloner) parts.push(`dc: ${c.defaultCloner}`);
+			if (c.objectDefaultMerger) parts.push(`pm: ${c.objectDefaultMerger}`);
 		}
 		if (c.customErrors?.length) {
 			const ce = c.customErrors.map((e) => `{ p: ${JSON.stringify(e.path)}, c: ${Source.checkFactory(e.identifier, Source.checkCode(e.checkDefs, e.checkValue))}${e.external ? ", e: 1" : ""} }`).join(", ");
@@ -98,6 +181,7 @@ function emitModule(captured, handlers, options) {
 			}).join(", ");
 			parts.push(`ic: [${ic}]`);
 		}
+		if (c.coercePlan) parts.push(`cp: ${JSON.stringify(c.coercePlan)}`);
 		return parts;
 	};
 	const treeToSource = (tree, slotRef, sink) => {
@@ -247,15 +331,19 @@ function emitModule(captured, handlers, options) {
 	handlerExport += "}\n";
 	if (options?.register) handlerExport += "Compiled.handlers = handlers\n";
 	let body = "// Generated by Elysia build plugin. Do not edit.\n";
-	if (options?.register) body += `import { Compiled } from ${JSON.stringify(options.registerFrom ?? "elysia")}\nimport { CheckContext } from 'typebox/schema'
-import { Guard } from 'typebox/guard'
-import { Format } from 'typebox/format'
-import { Hashing } from 'typebox/system'
-`;
+	if (options?.register) {
+		body += `import { Compiled } from ${JSON.stringify(options.registerFrom ?? "elysia")}\n`;
+		const generated = branchDecls + unionDecls + validatorDecls + handlerDecls;
+		const needs = (symbol) => new RegExp(`\\b${symbol}\\b`).test(generated);
+		if (needs("CheckContext")) body += "import { CheckContext } from 'typebox/schema'\n";
+		if (needs("Guard")) body += "import { Guard } from 'typebox/guard'\n";
+		if (needs("Format")) body += "import { Format } from 'typebox/format'\n";
+		if (needs("Hashing")) body += "import { Hashing } from 'typebox/system'\n";
+	}
 	body += "\n" + branchDecls + (branchDecls && "\n") + unionDecls + (unionDecls && "\n") + validatorDecls + handlerDecls + "\n" + validatorExport + "\n" + handlerExport;
 	if (!lazy) body += "\nexport default validators\n";
 	return body;
 }
 
 //#endregion
-export { autoGroupSize, compileToSource };
+export { analyzeStubbability, autoGroupSize, captureArtifacts, compileToSource, replayStubbability };

package/dist/plugin/vite.d.ts

@@ -23,6 +23,13 @@ interface ElysiaAotVitePlugin {
  *   plugins: [aot('src/index.ts')]
  * })
  * ```
+ *
+ * The plugin imports your entry to capture the compiled app, running its
+ * top-level code. `.listen()` is auto-skipped during build (gated on
+ * `ELYSIA_AOT_BUILD`), but any other import-time handle — a DB pool,
+ * `setInterval`, a queue consumer — can keep the build process alive after
+ * the bundle is written. Gate the side effect with
+ * `if (!process.env.ELYSIA_AOT_BUILD)`.
  */
 declare const aot: (entry: string, options?: ElysiaAotOptions) => ElysiaAotVitePlugin;
 //#endregion

package/dist/plugin/vite.js

@@ -18,17 +18,34 @@ const VIRTUAL = "\0elysia/compiled";
 *   plugins: [aot('src/index.ts')]
 * })
 * ```
+*
+* The plugin imports your entry to capture the compiled app, running its
+* top-level code. `.listen()` is auto-skipped during build (gated on
+* `ELYSIA_AOT_BUILD`), but any other import-time handle — a DB pool,
+* `setInterval`, a queue consumer — can keep the build process alive after
+* the bundle is written. Gate the side effect with
+* `if (!process.env.ELYSIA_AOT_BUILD)`.
 */
 const aot = (entry, options) => {
 	const entryPath = require_plugin_core.resolveEntry(entry);
 	const treeShake = options?.treeShake ?? true;
 	let source = "";
+	let stub = {
+		jit: false,
+		ws: false,
+		reconstruct: false,
+		cookie: false,
+		trace: false,
+		sucrose: false
+	};
 	return {
 		name: "elysia-aot",
 		enforce: "pre",
 		apply: "build",
 		async buildStart() {
-			source = await require_plugin_core.generateCompiledModule(entry, options);
+			const generated = await require_plugin_core.generateCompiledArtifacts(entry, options);
+			source = generated.source;
+			stub = generated.stub;
 		},
 		resolveId(id) {
 			if (id === "elysia/compiled") return VIRTUAL;
@@ -37,6 +54,10 @@ const aot = (entry, options) => {
 			if (id === VIRTUAL) return source;
 		},
 		transform(code, id) {
+			for (const key of Object.keys(require_plugin_core.STUB_SOURCES)) {
+				if (!stub[key]) continue;
+				for (const { filter, source: stubSource } of require_plugin_core.STUB_SOURCES[key]) if (filter.test(id)) return stubSource;
+			}
 			let out = code;
 			if (treeShake && SOURCE.test(id) && !id.includes("node_modules")) out = require_plugin_treeshake.rewriteTypeImport(out);
 			if (id === entryPath) out = `import 'elysia/compiled'\n${out}`;