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

package/dist/handler/fetch.mjs

@@ -1,11 +1,11 @@
-import { flattenChain, getLoosePath, isNotEmpty, nullObject, requestId } from "../utils.mjs";
-import { NotFound } from "../error.mjs";
+import { flattenChain, isNotEmpty, nullObject, requestId } from "../utils.mjs";
 import { handleSet } from "../adapter/utils.mjs";
+import { NotFound } from "../error.mjs";
 import { createContext } from "../context.mjs";
-import { defaultAdapter } from "../adapter/constants.mjs";
 import { cachedResponse, getAsyncIndexes } from "./utils.mjs";
-import { createErrorHandler } from "./error.mjs";
 import { createTracer } from "../trace.mjs";
+import { defaultAdapter } from "../adapter/constants.mjs";
+import { createErrorHandler } from "./error.mjs";
 import { decodeComponent } from "deuri";
 
 //#region src/handler/fetch.ts
@@ -28,11 +28,17 @@ const decodeParams = (params) => {
 	}
 	return params;
 };
-const catchError = (context, handleError, afterResponse) => (error) => {
+function finalizeError(context, handleError, afterResponse, error) {
 	const resp = handleError(context, error);
-	afterResponse?.(context);
+	if (!afterResponse) return resp;
+	if (resp instanceof Promise) return resp.then((r) => {
+		afterResponse(context);
+		return r;
+	});
+	afterResponse(context);
 	return resp;
-};
+}
+const catchError = (context, handleError, afterResponse) => (error) => finalizeError(context, handleError, afterResponse, error);
 function findRoute(context, request, map, router, hasError, handleError, afterResponse, strictPath, hasWS) {
 	const path = context.path;
 	if (hasWS) {
@@ -50,17 +56,23 @@ function findRoute(context, request, map, router, hasError, handleError, afterRe
 				return r instanceof Promise ? r.catch(catchError(context, handleError, afterResponse)) : r;
 			}
 		}
-	} else {
-		const handler = map[request.method]?.[path] ?? map["*"]?.[path];
+	}
+	{
+		const methodMap = map[request.method];
+		let handler = methodMap?.[path];
+		if (!handler) if (!strictPath && path.length > 1 && path.charCodeAt(path.length - 1) === 47) {
+			const loose = path.slice(0, -1);
+			handler = methodMap?.[loose];
+			if (!handler) {
+				const anyMap = map["*"];
+				handler = anyMap?.[path] ?? anyMap?.[loose];
+			}
+		} else handler = map["*"]?.[path];
 		if (handler) {
 			const r = handler(context);
 			return r instanceof Promise ? r.catch(catchError(context, handleError, afterResponse)) : r;
 		}
-		let found = router?.find(request.method, path) ?? router?.find("*", path);
-		if (!found && !strictPath) {
-			const loose = getLoosePath(path);
-			if (loose !== path) found = router?.find(request.method, loose) ?? router?.find("*", loose);
-		}
+		const found = router?.find(request.method, path) ?? router?.find("*", path);
 		if (found) {
 			context.params = decodeParams(found.params);
 			const r = found.store(context);
@@ -138,25 +150,27 @@ function createFetchHandler(app) {
 			const trace = new Array(traceLength);
 			for (let i = 0; i < traceLength; i++) trace[i] = tracerFactories[i](context);
 			context.trace = trace;
-			const requestReports = trace.map((c) => c.request({
+			const requestReports = new Array(traceLength);
+			for (let i = 0; i < traceLength; i++) requestReports[i] = trace[i].request({
 				id: context.rid,
 				event: "request",
 				name: "request",
 				begin: performance.now(),
 				total: onRequests.length
-			}));
+			});
 			try {
 				for (let i = 0; i < onRequests.length; i++) {
-					const endReports = requestReports.map((r) => r.resolveChild?.shift?.()?.({
+					const endReports = new Array(traceLength);
+					for (let j = 0; j < traceLength; j++) endReports[j] = requestReports[j].resolveChild?.shift?.()?.({
 						id: context.rid,
 						event: "request",
 						name: onRequests[i].name || "anonymous",
 						begin: performance.now()
-					}));
+					});
 					const result = asyncIndexes?.[i] ? await onRequests[i](context) : onRequests[i](context);
 					for (let i = 0; i < traceLength; i++) endReports[i]?.();
 					if (result !== void 0) {
-						requestReports.forEach((r) => r.resolve());
+						for (let j = 0; j < traceLength; j++) requestReports[j].resolve();
 						const response = mapResponse(result, context.set);
 						afterResponse?.(context);
 						return response;
@@ -166,9 +180,7 @@ function createFetchHandler(app) {
 				return await findRoute(context, request, map, router, hasError, handleError, afterResponse, strictPath, hasWS);
 			} catch (error) {
 				for (let i = 0; i < traceLength; i++) requestReports[i].resolve(error);
-				const r = handleError(context, error);
-				afterResponse?.(context);
-				return r;
+				return finalizeError(context, handleError, afterResponse, error);
 			}
 		};
 	}
@@ -190,9 +202,7 @@ function createFetchHandler(app) {
 				}
 				return findRoute(context, request, map, router, hasError, handleError, afterResponse, strictPath, hasWS);
 			} catch (error) {
-				const r = handleError(context, error);
-				afterResponse?.(context);
-				return r;
+				return finalizeError(context, handleError, afterResponse, error);
 			}
 		};
 		return (request) => {
@@ -210,7 +220,7 @@ function createFetchHandler(app) {
 				}
 				return findRoute(context, request, map, router, hasError, handleError, afterResponse, strictPath, hasWS);
 			} catch (error) {
-				return handleError(context, error);
+				return finalizeError(context, handleError, afterResponse, error);
 			}
 		};
 	}
@@ -234,38 +244,35 @@ function createFetchHandler(app) {
 						return r instanceof Promise ? r.catch(catchError(context, handleError, afterResponse)) : r;
 					}
 				} catch (error) {
-					const r = handleError(context, error);
-					afterResponse?.(context);
-					return r;
+					return finalizeError(context, handleError, afterResponse, error);
 				}
 			}
 		}
-		const handler = map[request.method]?.[path] ?? map["*"]?.[path];
+		const methodMap = map[request.method];
+		let handler = methodMap?.[path];
 		try {
+			if (!handler) if (!strictPath && path.length > 1 && path.charCodeAt(path.length - 1) === 47) {
+				const loose = path.slice(0, -1);
+				handler = methodMap?.[loose];
+				if (!handler) {
+					const anyMap = map["*"];
+					handler = anyMap?.[path] ?? anyMap?.[loose];
+				}
+			} else handler = map["*"]?.[path];
 			if (handler) {
 				const r = handler(context);
 				return r instanceof Promise ? r.catch(catchError(context, handleError, afterResponse)) : r;
 			}
-			let result = router?.find(request.method, path) ?? router?.find("*", path);
-			if (!result && !strictPath) {
-				const loose = getLoosePath(path);
-				if (loose !== path) result = router?.find(request.method, loose) ?? router?.find("*", loose);
-			}
+			const result = router?.find(request.method, path) ?? router?.find("*", path);
 			if (result) {
 				context.params = decodeParams(result.params);
 				const r = result.store(context);
 				return r instanceof Promise ? r.catch(catchError(context, handleError, afterResponse)) : r;
 			}
 		} catch (error) {
-			const r = handleError(context, error);
-			afterResponse?.(context);
-			return r;
-		}
-		if (hasError) {
-			const r = handleError(context, new NotFound());
-			afterResponse?.(context);
-			return r;
+			return finalizeError(context, handleError, afterResponse, error);
 		}
+		if (hasError) return finalizeError(context, handleError, afterResponse, new NotFound());
 		afterResponse?.(context, 404);
 		return notFound(context);
 	};

package/dist/index.d.ts

@@ -1,16 +1,21 @@
-import { StatusMap } from "./constants.js";
-import { ElysiaError, ElysiaStatus, InternalServerError, InvalidCookieSignature, NotFound, ParseError, ValidationError, status, validationDetail } from "./error.js";
+import { StatusMap, StatusMapBack } from "./constants.js";
+import { ElysiaError, ElysiaStatus, InternalServerError, InvalidCookieSignature, NotFound, ParseError, SelectiveStatus, ValidationError, status, validationDetail } from "./error.js";
+import { BaseCookie, CookieOptions } from "./cookie/types.js";
 import { Cookie } from "./cookie/cookie.js";
-import { serializeCookie } from "./cookie/utils.js";
 import { ElysiaFile, file } from "./universal/file.js";
-import { TraceEvent, TraceHandler, TraceListener, TraceProcess, TraceStream } from "./trace.js";
 import { env } from "./universal/env.js";
-import { SSEPayload } from "./types.js";
+import { Server } from "./universal/server.js";
+import { HTTPHeaders, InputSchema, Macro, MacroToContext, MacroToProperty, RouteSchema, SSEPayload, UnwrapRoute, UnwrapSchema } from "./types.js";
 import { AnySchema, BaseSchema, StandardJSONSchemaV1Like, StandardSchemaV1Like } from "./type/types.js";
+import { TCookieField, TCookieObject } from "./type/elysia/cookie.js";
 import { FileTypeDetector, fileType, setFileTypeDetector } from "./type/elysia/file-type.js";
+import { TFiles } from "./type/elysia/files.js";
+import { setupTypebox } from "./type/compat.js";
+import { Capture, Compiled } from "./compile/aot.js";
+import { MultiValidator, StandardValidator, Validator } from "./validator/index.js";
+import { TypeBoxValidator } from "./type/validator/index.js";
 import { TypeSystem, t } from "./type/index.js";
-import { form, redirect, sse } from "./utils.js";
+import { form, prefix, redirect, sse } from "./utils.js";
 import { Context, ErrorContext, createBaseContext, createContext } from "./context.js";
 import { Elysia } from "./base.js";
-import { Compiled } from "./compile/aot.js";
-export { type AnySchema, type BaseSchema, Compiled, type Context, Cookie, Elysia, Elysia as default, ElysiaError, ElysiaFile, ElysiaStatus, type ErrorContext, type FileTypeDetector, InternalServerError, InvalidCookieSignature, NotFound, ParseError, type SSEPayload, type StandardJSONSchemaV1Like, type StandardSchemaV1Like, StatusMap, type TraceEvent, type TraceHandler, type TraceListener, type TraceProcess, type TraceStream, TypeSystem, ValidationError, createBaseContext, createContext, env, file, fileType, form, redirect, serializeCookie, setFileTypeDetector, sse, status, t, validationDetail };
+export { type AnySchema, type BaseCookie, type BaseSchema, Compiled, type Context, type Cookie, type CookieOptions, Elysia, Elysia as default, ElysiaError, ElysiaFile, ElysiaStatus, type ErrorContext, type FileTypeDetector, type HTTPHeaders, type InputSchema, InternalServerError, InvalidCookieSignature, type Macro, type MacroToContext, type MacroToProperty, Capture as Manifest, MultiValidator, NotFound, ParseError, type RouteSchema, type SSEPayload, type SelectiveStatus, type Server, type StandardJSONSchemaV1Like, type StandardSchemaV1Like, StandardValidator, StatusMap, StatusMapBack, type TCookieField, type TCookieObject, type TFiles, TypeBoxValidator, TypeSystem, type UnwrapRoute, type UnwrapSchema, ValidationError, Validator, createBaseContext, createContext, env, file, fileType, form, prefix, redirect, setFileTypeDetector, setupTypebox, sse, status, t, validationDetail };

package/dist/index.js

@@ -3,14 +3,15 @@ const require_runtime = require('./_virtual/_rolldown/runtime.js');
 const require_constants = require('./constants.js');
 const require_universal_file = require('./universal/file.js');
 const require_utils = require('./utils.js');
-const require_cookie_cookie = require('./cookie/cookie.js');
 const require_universal_env = require('./universal/env.js');
 const require_error = require('./error.js');
-const require_cookie_utils = require('./cookie/utils.js');
 const require_context = require('./context.js');
 const require_compile_aot = require('./compile/aot.js');
+const require_validator_index = require('./validator/index.js');
 const require_base = require('./base.js');
 const require_type_elysia_file_type = require('./type/elysia/file-type.js');
+const require_type_validator_index = require('./type/validator/index.js');
+const require_type_compat = require('./type/compat.js');
 const require_type_index = require('./type/index.js');
 let typebox_system = require("typebox/system");
 
@@ -19,16 +20,20 @@ var src_default = require_base.Elysia;
 
 //#endregion
 exports.Compiled = require_compile_aot.Compiled;
-exports.Cookie = require_cookie_cookie.Cookie;
 exports.Elysia = require_base.Elysia;
 exports.ElysiaError = require_error.ElysiaError;
 exports.ElysiaFile = require_universal_file.ElysiaFile;
 exports.ElysiaStatus = require_error.ElysiaStatus;
 exports.InternalServerError = require_error.InternalServerError;
 exports.InvalidCookieSignature = require_error.InvalidCookieSignature;
+exports.Manifest = require_compile_aot.Capture;
+exports.MultiValidator = require_validator_index.MultiValidator;
 exports.NotFound = require_error.NotFound;
 exports.ParseError = require_error.ParseError;
+exports.StandardValidator = require_validator_index.StandardValidator;
 exports.StatusMap = require_constants.StatusMap;
+exports.StatusMapBack = require_constants.StatusMapBack;
+exports.TypeBoxValidator = require_type_validator_index.TypeBoxValidator;
 Object.defineProperty(exports, 'TypeSystem', {
   enumerable: true,
   get: function () {
@@ -36,6 +41,7 @@ Object.defineProperty(exports, 'TypeSystem', {
   }
 });
 exports.ValidationError = require_error.ValidationError;
+exports.Validator = require_validator_index.Validator;
 exports.createBaseContext = require_context.createBaseContext;
 exports.createContext = require_context.createContext;
 exports.default = src_default;
@@ -43,9 +49,10 @@ exports.env = require_universal_env.env;
 exports.file = require_universal_file.file;
 exports.fileType = require_type_elysia_file_type.fileType;
 exports.form = require_utils.form;
+exports.prefix = require_utils.prefix;
 exports.redirect = require_utils.redirect;
-exports.serializeCookie = require_cookie_utils.serializeCookie;
 exports.setFileTypeDetector = require_type_elysia_file_type.setFileTypeDetector;
+exports.setupTypebox = require_type_compat.setupTypebox;
 exports.sse = require_utils.sse;
 exports.status = require_error.status;
 exports.t = require_type_index.t;

package/dist/index.mjs

@@ -1,18 +1,19 @@
-import { StatusMap } from "./constants.mjs";
+import { StatusMap, StatusMapBack } from "./constants.mjs";
 import { ElysiaFile, file } from "./universal/file.mjs";
-import { form, redirect, sse } from "./utils.mjs";
-import { Cookie } from "./cookie/cookie.mjs";
+import { form, prefix, redirect, sse } from "./utils.mjs";
 import { env } from "./universal/env.mjs";
 import { ElysiaError, ElysiaStatus, InternalServerError, InvalidCookieSignature, NotFound, ParseError, ValidationError, status, validationDetail } from "./error.mjs";
-import { serializeCookie } from "./cookie/utils.mjs";
 import { createBaseContext, createContext } from "./context.mjs";
-import { Compiled } from "./compile/aot.mjs";
+import { Capture, Compiled } from "./compile/aot.mjs";
+import { MultiValidator, StandardValidator, Validator } from "./validator/index.mjs";
 import { Elysia } from "./base.mjs";
 import { fileType, setFileTypeDetector } from "./type/elysia/file-type.mjs";
+import { TypeBoxValidator } from "./type/validator/index.mjs";
+import { setupTypebox } from "./type/compat.mjs";
 import { TypeSystem, t } from "./type/index.mjs";
 
 //#region src/index.ts
 var src_default = Elysia;
 
 //#endregion
-export { Compiled, Cookie, Elysia, ElysiaError, ElysiaFile, ElysiaStatus, InternalServerError, InvalidCookieSignature, NotFound, ParseError, StatusMap, TypeSystem, ValidationError, createBaseContext, createContext, src_default as default, env, file, fileType, form, redirect, serializeCookie, setFileTypeDetector, sse, status, t, validationDetail };
+export { Compiled, Elysia, ElysiaError, ElysiaFile, ElysiaStatus, InternalServerError, InvalidCookieSignature, Capture as Manifest, MultiValidator, NotFound, ParseError, StandardValidator, StatusMap, StatusMapBack, TypeBoxValidator, TypeSystem, ValidationError, Validator, createBaseContext, createContext, src_default as default, env, file, fileType, form, prefix, redirect, setFileTypeDetector, setupTypebox, sse, status, t, validationDetail };

package/dist/parse-query.js

@@ -60,7 +60,7 @@ function parseQueryFromURL(input, startIndex = input.indexOf("?", 11), array, ob
 			}
 			else finalValue = finalValue.slice(1, -1).split(",");
 			if (currentValue === void 0) result[finalKey] = finalValue;
-			else if (Array.isArray(currentValue)) currentValue.push(...finalValue);
+			else if (Array.isArray(currentValue)) for (let i = 0; i < finalValue.length; i++) currentValue.push(finalValue[i]);
 			else {
 				result[finalKey] = finalValue;
 				result[finalKey].unshift(currentValue);

package/dist/parse-query.mjs

@@ -58,7 +58,7 @@ function parseQueryFromURL(input, startIndex = input.indexOf("?", 11), array, ob
 			}
 			else finalValue = finalValue.slice(1, -1).split(",");
 			if (currentValue === void 0) result[finalKey] = finalValue;
-			else if (Array.isArray(currentValue)) currentValue.push(...finalValue);
+			else if (Array.isArray(currentValue)) for (let i = 0; i < finalValue.length; i++) currentValue.push(finalValue[i]);
 			else {
 				result[finalKey] = finalValue;
 				result[finalKey].unshift(currentValue);

package/dist/plugin/bun.d.ts

@@ -17,7 +17,17 @@ import { BunPlugin } from "bun";
  *   outdir: 'dist',
  *   plugins: [aot('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) => BunPlugin;
 //#endregion

package/dist/plugin/bun.js

@@ -28,12 +28,22 @@ const realPath = (path) => {
 *   outdir: 'dist',
 *   plugins: [aot('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;
@@ -49,6 +59,13 @@ const aot = (entry, options) => ({
 			contents: source,
 			loader: "js"
 		}));
+		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/bun.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";
 
@@ -26,12 +26,22 @@ const realPath = (path) => {
 *   outdir: 'dist',
 *   plugins: [aot('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;
@@ -47,6 +57,13 @@ const aot = (entry, options) => ({
 			contents: source,
 			loader: "js"
 		}));
+		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/core.d.ts

@@ -33,10 +33,70 @@ interface ElysiaAotOptions {
    * @default true
    */
   treeShake?: boolean;
+  /**
+   * Replace the internal handler compiler with a throwing stub so the bundler
+   * can drop the handler-JIT graph
+   *
+   * This is only safe when every route is reconstructed from the frozen AOT
+   * handler manifest. The plugin verifies that by replaying a frozen build and
+   * watching whether handler JIT is reached
+   *
+   * - `'auto'` (default): stub only when the frozen replay proves handler JIT
+   *   is unused. Skip if any route still reaches handler JIT
+   * - `true`: require a fully precompiled handler manifest and throw if any
+   *   route still reaches handler JIT
+   * - `false`: never stub
+   *
+   * @default 'auto'
+   */
+  strip?: boolean | 'auto';
 }
 declare const resolveEntry: (entry: string) => string;
 declare function resolveLoader(entryPath: string): "js" | "jsx" | "tsx" | "ts";
 declare const entryFilter: (entryPath: string) => RegExp;
+/** Runtime handler-JIT module a strip build can replace with a throwing stub. */
+interface StubPlan {
+  /** Stub the internal handler codegen module. */
+  jit: boolean;
+  /** Stub internal WS route builders when the app declares no WS routes. */
+  ws: boolean;
+  /**
+   * Stub frozen-handler reconstruction (validator `va`, cookie `cc`, trace `tr`)
+   * when no replayed handler aliases any of them.
+   */
+  reconstruct: boolean;
+  /**
+   * Stub the request-side cookie machinery (parse / jar / signing in
+   * `cookie/utils` + `cookie/config`) when no replayed handler aliases the
+   * cookie config (`cc`)
+   */
+  cookie: boolean;
+  /**
+   * Stub the trace runtime (`trace.ts` `createTracer` + recorder machinery)
+   * when no replayed handler aliases trace (`tr`). The live fetch handler keeps
+   * `createTracer` importable but only calls it when trace handlers exist, so a
+   * throwing stub is unreachable once detection proves trace is unused
+   */
+  trace: boolean;
+  /**
+   * Stub the `memory` module's `clearSucroseCache` edge when handler JIT is
+   * stubbed. Sucrose never runs in a precompiled app, so its caches are always
+   * empty and the flush is a no-op — dropping the import lets the Sucrose
+   * analyzer tree-shake. `flushMemory`'s other clears are preserved, and the
+   * public `elysia/sucrose` module is left untouched
+   */
+  sucrose: boolean;
+}
+declare const STUB_SOURCES: Record<keyof StubPlan, Array<{
+  filter: RegExp;
+  source: string;
+}>>;
 declare function generateCompiledModule(file: string, options?: ElysiaAotOptions): Promise<string>;
+interface CompiledArtifacts {
+  source: string;
+  /** Handler-JIT modules detection proved safe to stub for this app. */
+  stub: StubPlan;
+}
+declare function generateCompiledArtifacts(file: string, options?: ElysiaAotOptions): Promise<CompiledArtifacts>;
 //#endregion
-export { ElysiaAotOptions, entryFilter, generateCompiledModule, resolveEntry, resolveLoader };
+export { CompiledArtifacts, ElysiaAotOptions, STUB_SOURCES, StubPlan, entryFilter, generateCompiledArtifacts, generateCompiledModule, resolveEntry, resolveLoader };

package/dist/plugin/core.js

@@ -20,22 +20,102 @@ 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 require_plugin_source.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 require_plugin_source.compileToSource(typedApp, sourceOptions),
+			stub: NO_STUB
+		};
+		const artifacts = await require_plugin_source.captureArtifacts(typedApp, sourceOptions);
+		const report = require_plugin_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.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
+exports.STUB_SOURCES = STUB_SOURCES;
 exports.entryFilter = entryFilter;
+exports.generateCompiledArtifacts = generateCompiledArtifacts;
 exports.generateCompiledModule = generateCompiledModule;
 exports.resolveEntry = resolveEntry;
 exports.resolveLoader = resolveLoader;