elysia 2.0.0-exp.3 → 2.0.0-exp.5

package/dist/adapter/utils.d.ts

@@ -18,10 +18,7 @@ interface CreateHandlerParameter {
   mapResponse(response: unknown, set: Context['set'], request?: Request): Response;
   mapCompactResponse(response: unknown, request?: Request): Response;
 }
-declare const createStreamHandler: ({
-  mapResponse,
-  mapCompactResponse
-}: CreateHandlerParameter) => (generator: Generator | AsyncGenerator | ReadableStream, set?: Context["set"], request?: Request, skipFormat?: boolean) => Promise<Response>;
+declare const createStreamHandler: (_: CreateHandlerParameter) => (generator: Generator | AsyncGenerator | ReadableStream, set?: Context["set"], request?: Request, skipFormat?: boolean) => Promise<Response>;
 declare function streamResponse(response: Response): AsyncGenerator<any, void, any>;
 declare function handleSet(set: Context['set']): void;
 declare function mergeHeaders(responseHeaders: Headers, setHeaders: Context['set']['headers']): Headers;

package/dist/adapter/utils.js

@@ -2,7 +2,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_universal_constants = require('../universal/constants.js');
 const require_constants = require('../constants.js');
 const require_utils = require('../utils.js');
-const require_cookie_utils = require('../cookie/utils.js');
+const require_cookie_serialize = require('../cookie/serialize.js');
+const require_adapter_web_standard_handler = require('./web-standard/handler.js');
 
 //#region src/adapter/utils.ts
 const setCookie = "set-cookie";
@@ -101,7 +102,7 @@ function responseToSetHeaders(response, set) {
 	} else if (set.headers["content-encoding"]) delete set.headers["content-encoding"];
 	return set;
 }
-const enqueueBinaryChunk = (controller, chunk) => {
+function enqueueBinaryChunk(controller, chunk) {
 	if (chunk instanceof Blob) return chunk.arrayBuffer().then((buffer) => {
 		controller.enqueue(new Uint8Array(buffer));
 		return true;
@@ -119,15 +120,15 @@ const enqueueBinaryChunk = (controller, chunk) => {
 		return true;
 	}
 	return false;
-};
-const createStreamHandler = ({ mapResponse, mapCompactResponse }) => async (generator, set, request, skipFormat) => {
+}
+const createStreamHandler = (_) => async (generator, set, request, skipFormat) => {
 	let init = generator.next?.();
 	if (set) handleSet(set);
 	if (init instanceof Promise) init = await init;
 	if (init?.value instanceof ReadableStream) generator = init.value;
 	else if (init && (typeof init?.done === "undefined" || init?.done)) {
-		if (set) return mapResponse(init.value, set, request);
-		return mapCompactResponse(init.value, request);
+		if (set) return require_adapter_web_standard_handler.mapResponse(init.value, set, request);
+		return require_adapter_web_standard_handler.mapCompactResponse(init.value, request);
 	}
 	const isSSE = !skipFormat && (init?.value?.sse ?? generator?.sse ?? set?.headers["content-type"]?.startsWith("text/event-stream"));
 	const format = isSSE ? (data) => `data: ${data}\n\n` : (data) => data;
@@ -217,7 +218,7 @@ function handleSet(set) {
 		set.headers = flat;
 	}
 	if (set.cookie && require_utils.isNotEmpty(set.cookie)) {
-		const cookie = require_cookie_utils.serializeCookie(set.cookie);
+		const cookie = require_cookie_serialize.serializeCookie(set.cookie);
 		if (cookie) set.headers[setCookie] = cookie;
 	}
 	if (set.headers[setCookie] && Array.isArray(set.headers[setCookie])) set.headers = parseSetCookies(new Headers(set.headers), set.headers[setCookie]);

package/dist/adapter/utils.mjs

@@ -1,7 +1,8 @@
 import { hasHeaderShorthand, isBun } from "../universal/constants.mjs";
 import { StatusMap } from "../constants.mjs";
 import { isNotEmpty, nullObject } from "../utils.mjs";
-import { serializeCookie } from "../cookie/utils.mjs";
+import { serializeCookie } from "../cookie/serialize.mjs";
+import { mapCompactResponse, mapResponse } from "./web-standard/handler.mjs";
 
 //#region src/adapter/utils.ts
 const setCookie = "set-cookie";
@@ -100,7 +101,7 @@ function responseToSetHeaders(response, set) {
 	} else if (set.headers["content-encoding"]) delete set.headers["content-encoding"];
 	return set;
 }
-const enqueueBinaryChunk = (controller, chunk) => {
+function enqueueBinaryChunk(controller, chunk) {
 	if (chunk instanceof Blob) return chunk.arrayBuffer().then((buffer) => {
 		controller.enqueue(new Uint8Array(buffer));
 		return true;
@@ -118,8 +119,8 @@ const enqueueBinaryChunk = (controller, chunk) => {
 		return true;
 	}
 	return false;
-};
-const createStreamHandler = ({ mapResponse, mapCompactResponse }) => async (generator, set, request, skipFormat) => {
+}
+const createStreamHandler = (_) => async (generator, set, request, skipFormat) => {
 	let init = generator.next?.();
 	if (set) handleSet(set);
 	if (init instanceof Promise) init = await init;

package/dist/adapter/web-standard/handler.js

@@ -2,8 +2,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_universal_constants = require('../../universal/constants.js');
 const require_universal_file = require('../../universal/file.js');
 const require_utils = require('../../utils.js');
-const require_error = require('../../error.js');
 const require_adapter_utils = require('../utils.js');
+const require_error = require('../../error.js');
 
 //#region src/adapter/web-standard/handler.ts
 function handleElysiaFile(file, set = { headers: require_utils.nullObject() }, request) {

package/dist/adapter/web-standard/handler.mjs

@@ -1,8 +1,8 @@
 import { isBun } from "../../universal/constants.mjs";
 import { mime } from "../../universal/file.mjs";
 import { formToFormData, isNotEmpty, nullObject } from "../../utils.mjs";
-import { ElysiaStatus, isProduction } from "../../error.mjs";
 import { createResponseHandler, createStreamHandler, handleFile, handleSet } from "../utils.mjs";
+import { ElysiaStatus, isProduction } from "../../error.mjs";
 
 //#region src/adapter/web-standard/handler.ts
 function handleElysiaFile(file, set = { headers: nullObject() }, request) {

package/dist/base.d.ts

@@ -43,7 +43,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
   '~map'?: {
     [method: string]: {
       [path: string]: CompiledHandler;
-    };
+    } | undefined;
   };
   '~staticResponse'?: {
     [path: string]: {

package/dist/base.js

@@ -378,7 +378,7 @@ var Elysia = class Elysia {
 		return this;
 	}
 	macro(macro) {
-		if (typeof macro === "function") throw new Error("Use `.macro({ name: fn })` instead of `.macro(fn)`");
+		if (typeof macro === "function") throw new Error("use `.macro({ name: fn })` instead of `.macro(fn)`");
 		const ext = this.#ext;
 		const m = ext.macro ??= require_utils.nullObject();
 		for (const key in macro) if (typeof macro[key] === "object") macro[key] = require_utils.hookToGuard(macro[key]);
@@ -813,13 +813,13 @@ var Elysia = class Elysia {
 	}
 	#initMap() {
 		this["~map"] ??= {
-			GET: require_utils.nullObject(),
-			POST: require_utils.nullObject(),
-			PUT: require_utils.nullObject(),
-			DELETE: require_utils.nullObject(),
-			PATCH: require_utils.nullObject(),
-			HEAD: require_utils.nullObject(),
-			OPTIONS: require_utils.nullObject()
+			GET: void 0,
+			POST: void 0,
+			PUT: void 0,
+			DELETE: void 0,
+			PATCH: void 0,
+			HEAD: void 0,
+			OPTIONS: void 0
 		};
 	}
 	compile() {
@@ -897,6 +897,8 @@ var Elysia = class Elysia {
 		}
 		const wrapHeadHandler = Elysia.#wrapHeadHandler;
 		const strict = !!this["~config"]?.strictPath;
+		const routerOptions = strict ? void 0 : { loosePath: true };
+		const getRouter = () => this["~router"] ??= new memoirist.default(routerOptions);
 		let explicitPaths;
 		if (!strict && this["~config"]?.distinctPath) {
 			explicitPaths = /* @__PURE__ */ new Map();
@@ -921,7 +923,7 @@ var Elysia = class Elysia {
 				const ws = require_ws_route.buildWSRoute(route, this);
 				const handler = ws[0];
 				const options = ws[1];
-				if (require_constants.isDynamicRegex.test(path)) (this["~router"] ??= new memoirist.default()).add("WS", path, handler, false);
+				if (require_constants.isDynamicRegex.test(path)) getRouter().add("WS", path, handler, false);
 				else {
 					this.#initMap();
 					const wsMap = this["~map"]["WS"] ??= require_utils.nullObject();
@@ -961,8 +963,18 @@ var Elysia = class Elysia {
 			const sharedStatic = maybeStatic && staticResponse instanceof Response ? staticResponse : void 0;
 			const autoHead = enableAutoHead && method === "GET" && !explicitHead?.has(path);
 			const isDynamic = require_constants.isDynamicRegex.test(path);
-			const registerLoose = !isDynamic && !strict;
+			const registerLoose = !isDynamic && !strict && (path.length === 0 || path.charCodeAt(path.length - 1) === 47);
 			const explicitMain = registerLoose ? explicitPaths?.get(method) : void 0;
+			if (!isDynamic && !require_constants.needEncodeRegex.test(path) && !registerLoose) {
+				const map = methods[method] ??= require_utils.nullObject();
+				const handler = this.handler(i, precompile, route, sharedStatic);
+				map[path] = handler;
+				if (autoHead) {
+					const head = methods["HEAD"] ??= require_utils.nullObject();
+					head[path] = wrapHeadHandler(handler);
+				}
+				continue;
+			}
 			const variants = [path];
 			if (require_constants.needEncodeRegex.test(path)) {
 				const encoded = encodeURI(path);
@@ -978,7 +990,7 @@ var Elysia = class Elysia {
 				}
 			}
 			if (isDynamic) {
-				const router = this["~router"] ??= new memoirist.default();
+				const router = getRouter();
 				const handler = this.handler(i, precompile, void 0, sharedStatic);
 				const headHandler = autoHead ? wrapHeadHandler(handler) : void 0;
 				for (let p = 0; p < paths.length; p++) {
@@ -1018,7 +1030,7 @@ var Elysia = class Elysia {
 		return this;
 	}
 	wrap(callback) {
-		if (this.#fetchFn) console.warn("[Elysia] .wrap() was called after the fetch handler was built, so it will not take effect. Register .wrap() before .listen() or before accessing .fetch/.handle.");
+		if (this.#fetchFn) console.warn("[Elysia] .wrap() was called after the fetch handler was built");
 		const ext = this.#ext;
 		(ext.hoc ??= []).push(callback);
 		return this;

package/dist/base.mjs

@@ -375,7 +375,7 @@ var Elysia = class Elysia {
 		return this;
 	}
 	macro(macro) {
-		if (typeof macro === "function") throw new Error("Use `.macro({ name: fn })` instead of `.macro(fn)`");
+		if (typeof macro === "function") throw new Error("use `.macro({ name: fn })` instead of `.macro(fn)`");
 		const ext = this.#ext;
 		const m = ext.macro ??= nullObject();
 		for (const key in macro) if (typeof macro[key] === "object") macro[key] = hookToGuard(macro[key]);
@@ -810,13 +810,13 @@ var Elysia = class Elysia {
 	}
 	#initMap() {
 		this["~map"] ??= {
-			GET: nullObject(),
-			POST: nullObject(),
-			PUT: nullObject(),
-			DELETE: nullObject(),
-			PATCH: nullObject(),
-			HEAD: nullObject(),
-			OPTIONS: nullObject()
+			GET: void 0,
+			POST: void 0,
+			PUT: void 0,
+			DELETE: void 0,
+			PATCH: void 0,
+			HEAD: void 0,
+			OPTIONS: void 0
 		};
 	}
 	compile() {
@@ -894,6 +894,8 @@ var Elysia = class Elysia {
 		}
 		const wrapHeadHandler = Elysia.#wrapHeadHandler;
 		const strict = !!this["~config"]?.strictPath;
+		const routerOptions = strict ? void 0 : { loosePath: true };
+		const getRouter = () => this["~router"] ??= new Memoirist(routerOptions);
 		let explicitPaths;
 		if (!strict && this["~config"]?.distinctPath) {
 			explicitPaths = /* @__PURE__ */ new Map();
@@ -918,7 +920,7 @@ var Elysia = class Elysia {
 				const ws = buildWSRoute(route, this);
 				const handler = ws[0];
 				const options = ws[1];
-				if (isDynamicRegex.test(path)) (this["~router"] ??= new Memoirist()).add("WS", path, handler, false);
+				if (isDynamicRegex.test(path)) getRouter().add("WS", path, handler, false);
 				else {
 					this.#initMap();
 					const wsMap = this["~map"]["WS"] ??= nullObject();
@@ -958,8 +960,18 @@ var Elysia = class Elysia {
 			const sharedStatic = maybeStatic && staticResponse instanceof Response ? staticResponse : void 0;
 			const autoHead = enableAutoHead && method === "GET" && !explicitHead?.has(path);
 			const isDynamic = isDynamicRegex.test(path);
-			const registerLoose = !isDynamic && !strict;
+			const registerLoose = !isDynamic && !strict && (path.length === 0 || path.charCodeAt(path.length - 1) === 47);
 			const explicitMain = registerLoose ? explicitPaths?.get(method) : void 0;
+			if (!isDynamic && !needEncodeRegex.test(path) && !registerLoose) {
+				const map = methods[method] ??= nullObject();
+				const handler = this.handler(i, precompile, route, sharedStatic);
+				map[path] = handler;
+				if (autoHead) {
+					const head = methods["HEAD"] ??= nullObject();
+					head[path] = wrapHeadHandler(handler);
+				}
+				continue;
+			}
 			const variants = [path];
 			if (needEncodeRegex.test(path)) {
 				const encoded = encodeURI(path);
@@ -975,7 +987,7 @@ var Elysia = class Elysia {
 				}
 			}
 			if (isDynamic) {
-				const router = this["~router"] ??= new Memoirist();
+				const router = getRouter();
 				const handler = this.handler(i, precompile, void 0, sharedStatic);
 				const headHandler = autoHead ? wrapHeadHandler(handler) : void 0;
 				for (let p = 0; p < paths.length; p++) {
@@ -1015,7 +1027,7 @@ var Elysia = class Elysia {
 		return this;
 	}
 	wrap(callback) {
-		if (this.#fetchFn) console.warn("[Elysia] .wrap() was called after the fetch handler was built, so it will not take effect. Register .wrap() before .listen() or before accessing .fetch/.handle.");
+		if (this.#fetchFn) console.warn("[Elysia] .wrap() was called after the fetch handler was built");
 		const ext = this.#ext;
 		(ext.hoc ??= []).push(callback);
 		return this;

package/dist/compile/aot.d.ts

@@ -33,7 +33,10 @@ interface FrozenValidator {
   r?: 1;
   ps?: 1;
   pd?: unknown;
+  pn?: 1;
   pod?: Record<string, unknown>;
+  dc?: () => unknown;
+  pm?: (value: Record<string, unknown>) => Record<string, unknown>;
   ce?: Array<{
     p: string;
     c: FrozenCheckFactory;
@@ -63,6 +66,13 @@ interface HandlerManifest {
     [path: string]: FrozenHandler;
   };
 }
+interface CompiledSnapshot {
+  validators: ValidatorManifest | undefined;
+  handlers: HandlerManifest | undefined;
+  lazyGroups: Array<() => ValidatorManifest> | undefined;
+  lazyGroupOf: Record<string, Record<string, number>> | undefined;
+  builtGroups: number[];
+}
 declare abstract class Compiled {
   static get handlers(): HandlerManifest | undefined;
   static set handlers(manifest: HandlerManifest);
@@ -71,6 +81,10 @@ declare abstract class Compiled {
   static registerLazyValidators(groups: Array<() => ValidatorManifest>, groupOf: Record<string, Record<string, number>>): void;
   static getValidator(method: string, path: string, slot: ValidatorSlot): FrozenValidator | undefined;
   static hasValidator(method: string, path: string, slot: ValidatorSlot): boolean;
+  /** @internal preserve registry around in-process AOT analysis */
+  static snapshot(): CompiledSnapshot;
+  /** @internal restore registry after in-process AOT analysis */
+  static restore(snapshot: CompiledSnapshot): void;
   /** @internal test isolation */
   static clear(): void;
 }
@@ -145,7 +159,10 @@ interface CapturedValidator {
   encodeMirror?: CapturedMirror;
   precomputeSafe?: boolean;
   precomputedDefault?: unknown;
+  precomputeNull?: boolean;
   precomputedObjectDefault?: Record<string, unknown>;
+  defaultCloner?: string;
+  objectDefaultMerger?: string;
   customErrors?: Array<{
     path: string;
     identifier: string;
@@ -186,4 +203,4 @@ declare const Capture: {
   readonly isCapturing: () => boolean;
 };
 //#endregion
-export { Capture, CapturedHandler, CapturedMirror, CapturedValidator, CheckBuildResult, Compiled, EMPTY_EXTERNALS, FrozenBothFactory, FrozenCheckFactory, FrozenHandler, FrozenMirror, FrozenMirrorFactory, FrozenValidator, HandlerManifest, Source, ValidatorManifest, ValidatorSlot, beginValidatorCapture, collectExternals, endHandlerCapture, endValidatorCapture, externalsMatch, instantiateFrozenBoth, instantiateFrozenDecodeMirror, instantiateFrozenEncodeMirror, instantiateFrozenMirror, reconstructCheck };
+export { Capture, CapturedHandler, CapturedMirror, CapturedValidator, CheckBuildResult, Compiled, CompiledSnapshot, EMPTY_EXTERNALS, FrozenBothFactory, FrozenCheckFactory, FrozenHandler, FrozenMirror, FrozenMirrorFactory, FrozenValidator, HandlerManifest, Source, ValidatorManifest, ValidatorSlot, beginValidatorCapture, collectExternals, endHandlerCapture, endValidatorCapture, externalsMatch, instantiateFrozenBoth, instantiateFrozenDecodeMirror, instantiateFrozenEncodeMirror, instantiateFrozenMirror, reconstructCheck };

package/dist/compile/aot.js

@@ -48,6 +48,25 @@ var Compiled = class {
 	static hasValidator(method, path, slot) {
 		return validators?.[method]?.[path]?.[slot] !== void 0 || lazyGroupOf?.[method]?.[path] !== void 0;
 	}
+	/** @internal preserve registry around in-process AOT analysis */
+	static snapshot() {
+		return {
+			validators,
+			handlers,
+			lazyGroups,
+			lazyGroupOf,
+			builtGroups: [...builtGroups]
+		};
+	}
+	/** @internal restore registry after in-process AOT analysis */
+	static restore(snapshot) {
+		validators = snapshot.validators;
+		handlers = snapshot.handlers;
+		lazyGroups = snapshot.lazyGroups;
+		lazyGroupOf = snapshot.lazyGroupOf;
+		builtGroups.clear();
+		for (const group of snapshot.builtGroups) builtGroups.add(group);
+	}
 	/** @internal test isolation */
 	static clear() {
 		validators = void 0;

package/dist/compile/aot.mjs

@@ -47,6 +47,25 @@ var Compiled = class {
 	static hasValidator(method, path, slot) {
 		return validators?.[method]?.[path]?.[slot] !== void 0 || lazyGroupOf?.[method]?.[path] !== void 0;
 	}
+	/** @internal preserve registry around in-process AOT analysis */
+	static snapshot() {
+		return {
+			validators,
+			handlers,
+			lazyGroups,
+			lazyGroupOf,
+			builtGroups: [...builtGroups]
+		};
+	}
+	/** @internal restore registry after in-process AOT analysis */
+	static restore(snapshot) {
+		validators = snapshot.validators;
+		handlers = snapshot.handlers;
+		lazyGroups = snapshot.lazyGroups;
+		lazyGroupOf = snapshot.lazyGroupOf;
+		builtGroups.clear();
+		for (const group of snapshot.builtGroups) builtGroups.add(group);
+	}
 	/** @internal test isolation */
 	static clear() {
 		validators = void 0;

package/dist/compile/handler/index.d.ts

@@ -1,9 +1,9 @@
 import { AnyLocalHook, CompiledHandler, InternalRoute } from "../../types.js";
 import { ChainNode } from "../../utils.js";
 import { AnyElysia } from "../../base.js";
+import { setCaptureHeaderShorthand } from "./jit.js";
 
 //#region src/compile/handler/index.d.ts
-declare const setCaptureHeaderShorthand: (value: boolean | undefined) => void;
 declare function buildNativeStaticResponse([,, handler, instance, localHook, appHook, inheritedChain]: InternalRoute, root: AnyElysia): Response | Promise<Response> | undefined;
 declare function composeRouteHook(instance: AnyElysia, localHook: Partial<AnyLocalHook> | undefined, appHook: ChainNode | undefined, inheritedChain: ChainNode | undefined, root: AnyElysia): AnyLocalHook | undefined;
 declare function compileHandler([_method, path, handler, instance, localHook, appHook, inheritedChain]: InternalRoute, root: AnyElysia, precomputedStatic?: Response): CompiledHandler;