elysia 2.0.0-beta.1 → 2.0.0-beta.3

package/dist/base.mjs

@@ -2,7 +2,7 @@ import { isBun } from "./universal/constants.mjs";
 import { clonePlainDecorators, clonePlainDeep, coalesceSchemas, createErrorEventHandler, eventProperties, fnOrigin, fnv1a, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isEmpty, isNotEmpty, isRecordNumber, joinPath, macroOrigin, mapDeriveEntry, mergeDeep, mergeResponse, nullObject, pushField, schemaProperties, serializeMacroSeed } from "./utils.mjs";
 import { Ref } from "./type/bridge.mjs";
 import { isProduction } from "./universal/is-production.mjs";
-import { Capture, Compiled, beginCompilerSession, createAotFingerprint, createProgramId, endCompilerSession } from "./compile/aot.mjs";
+import { Capture, Compiled, beginCompilerSession, createAotFingerprint, endCompilerSession } from "./compile/aot.mjs";
 import { traceCapabilityRequired, wsCapabilityRequired } from "./generation.mjs";
 import { compileHandler, composeRouteHook, localMacroRoot, resolveLocalHook } from "./compile/handler/index.mjs";
 import { RouteFlag, buildRouteTable, routeRow } from "./route-table.mjs";
@@ -16,6 +16,29 @@ import Memoirist from "memoirist";
 const useNodesBuffer = [];
 const emptyHistory = Object.freeze([]);
 const canRegisterLoose = (path, isDynamic) => !isDynamic && (path.length === 0 || path.charCodeAt(path.length - 1) === 47);
+/**
+* Every key a single route must answer to, in registration order.
+*
+* `registerLoose` is the caller's call, not this helper's: HTTP gates it on
+* `canRegisterLoose` because its lookup retries the trailing slash, while WS
+* has no such retry and must own both directions outright
+*/
+const expandPaths = (path, needsEncode, registerLoose, explicit) => {
+	const variants = [path];
+	if (needsEncode) {
+		const encoded = encodeURI(path);
+		if (encoded !== path) variants.push(encoded);
+	}
+	if (!registerLoose) return variants;
+	const paths = [];
+	for (let v = 0; v < variants.length; v++) {
+		const p = variants[v];
+		paths.push(p);
+		const loose = getLoosePath(p);
+		if (loose !== p && !explicit?.has(loose)) paths.push(loose);
+	}
+	return paths;
+};
 var Elysia = class Elysia {
 	#hasPlugin;
 	#hasGlobal;
@@ -77,11 +100,14 @@ var Elysia = class Elysia {
 	#jitRoute;
 	#jitStatic;
 	#jitAliases;
+	get ["~programId"]() {
+		return this;
+	}
 	constructor(config) {
 		/**
 		* ! Don't tune
 		*
-		* Interesting JSC internal: These `= undefined` are load-bearing
+		* Interesting JSC internal: These `= undefined` shouldn't be removed
 		*
 		* Inline slots live inside the object cell, so JSC must pick their
 		* count at allocation before any initializer runs
@@ -99,7 +125,8 @@ var Elysia = class Elysia {
 		* Don't omitted field either for monomorphic access
 		*
 		* @see test/memory/instance-footprint.test.ts
-		* Est. Overflow 37 -> 21 = butterfly 64 -> 32 slots = 738B -> 450B/instance
+		* Est. overflow 37 -> 21 = butterfly 64 -> 32 slots = 738B -> 450B;
+		* reusing the app as its program identity brings the current cell to ~386B.
 		**/
 		this["~config"] = config;
 		this["~ext"] = void 0;
@@ -119,7 +146,6 @@ var Elysia = class Elysia {
 		this["~introspect"] = void 0;
 		this["~scopeChild"] = void 0;
 		this["~scopeChildren"] = void 0;
-		this["~programId"] = createProgramId();
 		if (config) {
 			const { prefix, name, seed, adapter } = config;
 			this["~Prefix"] = prefix ? prefix.charCodeAt(0) === 47 ? prefix : `/${prefix}` : void 0;
@@ -499,7 +525,7 @@ var Elysia = class Elysia {
 		invalidateMacroEpoch();
 		return this;
 	}
-	"~applyMacro"(input, toApply = input, iteration = 0, seen = /* @__PURE__ */ new Set()) {
+	"~applyMacro"(input, toApply = input, iteration = 0, seen = /* @__PURE__ */ new Set(), insertions = /* @__PURE__ */ new Map()) {
 		if (iteration >= 16) return input;
 		const macro = this["~ext"]?.macro;
 		if (!macro) return input;
@@ -544,7 +570,7 @@ var Elysia = class Elysia {
 					continue;
 				}
 				if (k in macro) {
-					this["~applyMacro"](input, { [k]: v }, iteration + 1, seen);
+					this["~applyMacro"](input, { [k]: v }, iteration + 1, seen, insertions);
 					delete input[key];
 					continue;
 				}
@@ -565,19 +591,20 @@ var Elysia = class Elysia {
 					delete input[key];
 					continue;
 				}
-				if (k in input) {
-					if (eventProperties.has(k) || k === "derive") {
-						const macroFns = Array.isArray(v) ? v : [v];
-						const existing = Array.isArray(input[k]) ? input[k] : [input[k]];
-						const merged = [];
-						const seen = /* @__PURE__ */ new Set();
-						for (const fn of macroFns) if (!existing.includes(fn) && !seen.has(fn)) {
-							seen.add(fn);
-							merged.push(fn);
-						}
-						for (const fn of existing) if (!seen.has(fn)) merged.push(fn);
-						input[k] = merged;
-					} else if (Array.isArray(input[k])) {
+				if (eventProperties.has(k) || k === "derive") {
+					const incoming = Array.isArray(v) ? v : [v];
+					const existing = k in input ? Array.isArray(input[k]) ? input[k] : [input[k]] : [];
+					const added = [];
+					for (const fn of incoming) if (!existing.includes(fn) && !added.includes(fn)) added.push(fn);
+					const at = insertions.get(k) ?? 0;
+					input[k] = [
+						...existing.slice(0, at),
+						...added,
+						...existing.slice(at)
+					];
+					insertions.set(k, at + added.length);
+				} else if (k in input) {
+					if (Array.isArray(input[k])) {
 						if (Array.isArray(v)) {
 							for (const item of v) if (!input[k].some((e) => e === item)) input[k].unshift(item);
 						} else if (!input[k].some((item) => item === v)) input[k].unshift(v);
@@ -1179,10 +1206,10 @@ var Elysia = class Elysia {
 		this.fetch;
 		return this;
 	}
-	handler(index, immediate = this["~config"]?.precompile, route, precomputedStatic, aliases, table) {
+	handler(index, immediate, route, precomputedStatic, aliases, table) {
 		if (this.#compiled?.[index]) return this.#compiled[index];
 		const compiled = this.#compiled ??= new Array(table?.length ?? this["~routes"].length);
-		if (immediate) {
+		if (immediate ?? this["~config"]?.precompile) {
 			const row = route ?? (table ? routeRow(table, index) : this["~routes"][index]);
 			let handler;
 			try {
@@ -1410,7 +1437,10 @@ var Elysia = class Elysia {
 		const appChain = this["~hookChain"];
 		if (this["~ext"]?.macro || this["~scopeChildren"] || appChain !== void 0 && appChain.refs) for (let i = 0; i < length; i++) this.#assertRouteModelRefs(routeRow(table, i), method[i]);
 		else for (let i = 0; i < length; i++) if (this.#routeMayHaveModelRef(table, i)) this.#assertRouteModelRefs(routeRow(table, i), method[i]);
-		if (length) Compiled.claim(this["~programId"], this["~aotFingerprint"] = createAotFingerprint());
+		if (length) {
+			const programId = this["~programId"];
+			if (!Compiled.claim(programId, this["~aotFingerprint"] = createAotFingerprint())) Compiled.assertUncontested(programId);
+		}
 		const isLoose = this["~config"]?.strictPath !== true;
 		let explicitPaths;
 		if (isLoose && table.hasLoose) {
@@ -1436,17 +1466,17 @@ var Elysia = class Elysia {
 				const handler = ws[0];
 				const options = ws[1];
 				if (wsConfig === void 0 && wsCap.options) wsConfig = wsCap.options;
+				const wsNeedsEncode = (routeFlags & RouteFlag.Encode) !== 0;
 				if ((routeFlags & RouteFlag.Dynamic) !== 0) {
-					(this["~router"] ??= new Memoirist({ loosePath: isLoose })).add("WS", routePath, handler);
+					const wsRouter = this["~router"] ??= new Memoirist({ loosePath: isLoose });
+					const wsPaths = expandPaths(routePath, wsNeedsEncode, false, void 0);
+					for (let v = 0; v < wsPaths.length; v++) wsRouter.add("WS", wsPaths[v], handler);
 					this["~hasDynamicWS"] = true;
 				} else {
 					this.#initMap();
 					const wsMap = this["~map"]["WS"] ??= nullObject();
-					wsMap[routePath] = handler;
-					if (isLoose) {
-						const loose = getLoosePath(routePath);
-						if (loose !== routePath && !explicitPaths?.get("WS")?.has(loose)) wsMap[loose] = handler;
-					}
+					const wsPaths = expandPaths(routePath, wsNeedsEncode, isLoose, isLoose ? explicitPaths?.get("WS") : void 0);
+					for (let v = 0; v < wsPaths.length; v++) wsMap[wsPaths[v]] = handler;
 				}
 				if (options && isNotEmpty(options)) {
 					wsConfig ??= nullObject();
@@ -1457,26 +1487,12 @@ var Elysia = class Elysia {
 			const isDynamic = (routeFlags & RouteFlag.Dynamic) !== 0;
 			const needsEncode = (routeFlags & RouteFlag.Encode) !== 0;
 			const registerLoose = isLoose && canRegisterLoose(routePath, isDynamic);
-			const explicitMain = registerLoose ? explicitPaths?.get(routeMethod) : void 0;
 			if (!isDynamic && !needsEncode && !registerLoose) {
 				const map = methods[routeMethod] ??= nullObject();
 				map[routePath] = this.handler(i, precompile, void 0, void 0, void 0, table);
 				continue;
 			}
-			const variants = [routePath];
-			if (needsEncode) {
-				const encoded = encodeURI(routePath);
-				if (encoded !== routePath) variants.push(encoded);
-			}
-			const paths = [];
-			for (let v = 0; v < variants.length; v++) {
-				const p = variants[v];
-				paths.push(p);
-				if (registerLoose) {
-					const loose = getLoosePath(p);
-					if (loose !== p && !explicitMain?.has(loose)) paths.push(loose);
-				}
-			}
+			const paths = expandPaths(routePath, needsEncode, registerLoose, registerLoose ? explicitPaths?.get(routeMethod) : void 0);
 			if (isDynamic) {
 				const router = this["~router"] ??= new Memoirist({ loosePath: isLoose });
 				const handler = this.handler(i, precompile, void 0, void 0, void 0, table);
@@ -1508,6 +1524,21 @@ var Elysia = class Elysia {
 		if (!Capture.isAotBuildEnv()) listen(this, options, callback);
 		return this;
 	}
+	/**
+	* Add a higher order function over Elysia.fetch
+	*
+	* @example
+	* ```ts
+	* const ctx = new AsyncLocalStorage<{ counter: number }>()
+	*
+	* new Elysia()
+	*	.wrap(
+	*		(fetch) => (request) =>
+	*			ctx.run({ counter: 0 }, () => fetch(request))
+	*	)
+	*	.get('/', () => ctx.getStore())
+	* ```
+	*/
 	wrap(callback) {
 		this.#assertMutable("wrap");
 		if (this.#fetchFn && !this.#pending) console.warn("[Elysia] .wrap() was called after the fetch handler was built");

package/dist/compile/aot-capture.js

@@ -282,7 +282,7 @@ function captureBridgeFree(aot, slot, rawSchema) {
 			path: aot.path,
 			slot
 		}, { bridgeFree });
-		if (bridgeFree && !require_compile_handler_frozen_validator.isCompactDiagnosable(coerced)) warnCompactErrorLoss(aot, slot);
+		if (bridgeFree && !require_compile_handler_frozen_validator.isCompactWalkable(coerced)) warnCompactErrorLoss(aot, slot);
 	}
 }
 function beginValidatorCapture() {

package/dist/compile/aot-capture.mjs

@@ -2,7 +2,7 @@ import { nullObject } from "../utils.mjs";
 import { env } from "../universal/env.mjs";
 import { Capture, CompilerState, aotActivationError, captureImpl, setCaptureImpl } from "./aot.mjs";
 import { isAsyncPredicate } from "../type/elysia/file-type.mjs";
-import { isCapturedBridgeFree, isCompactDiagnosable } from "./handler/frozen-validator.mjs";
+import { isCapturedBridgeFree, isCompactWalkable } from "./handler/frozen-validator.mjs";
 import { buildCoercedFromPlan, captureCoercePlan } from "../type/coerce.mjs";
 import { applyPrecomputed, buildDefaultClonerSource, buildObjectDefaultMergeSource, canonical, createMergerFromSource, setDefaultProbeImpl, verifyPreallocatableDefault } from "../type/validator/default-precompute.mjs";
 import { collectExternals } from "./aot-reconstruct.mjs";
@@ -280,7 +280,7 @@ function captureBridgeFree(aot, slot, rawSchema) {
 			path: aot.path,
 			slot
 		}, { bridgeFree });
-		if (bridgeFree && !isCompactDiagnosable(coerced)) warnCompactErrorLoss(aot, slot);
+		if (bridgeFree && !isCompactWalkable(coerced)) warnCompactErrorLoss(aot, slot);
 	}
 }
 function beginValidatorCapture() {

package/dist/compile/aot.d.ts

@@ -8,8 +8,7 @@ interface AotFingerprint {
 interface ProgramId {
   readonly _: unique symbol;
 }
-declare const createProgramId: () => ProgramId;
-declare function createAotFingerprint(): AotFingerprint;
+declare const createAotFingerprint: () => AotFingerprint;
 interface CompilerSession {
   readonly sucroseCache: Map<number, {
     content: string;
@@ -91,7 +90,7 @@ interface HandlerManifest {
 }
 interface CompiledSnapshot {
   registered: CompiledProgramRegistration | undefined;
-  claimed: boolean;
+  claimed: WeakRef<ProgramId> | undefined;
   programs: WeakMap<ProgramId, CompiledProgram>;
 }
 interface CompiledProgramRegistration {
@@ -131,6 +130,7 @@ declare function reconstruct(): ReconstructImpl;
 declare abstract class Compiled {
   static register(manifest: CompiledProgramRegistration): void;
   static claim(id: ProgramId, fingerprint: AotFingerprint): boolean;
+  static assertUncontested(id: ProgramId): void;
   static get reconstruct(): ReconstructImpl | undefined;
   static set reconstruct(impl: ReconstructImpl | undefined);
   static getHandler(id: ProgramId | undefined, method: string, path: string): FrozenHandler | undefined;
@@ -284,4 +284,4 @@ interface CaptureImpl {
 declare let captureImpl: CaptureImpl | undefined;
 declare function setCaptureImpl(impl: CaptureImpl | undefined): void;
 //#endregion
-export { AOT_ABI, AOT_MANIFEST_FORMAT, AotFingerprint, Capture, CaptureImpl, CapturedHandler, CapturedMirror, CapturedValidator, CheckBuildResult, Compiled, CompiledProgramRegistration, CompiledSnapshot, CompilerSession, CompilerState, EMPTY_EXTERNALS, FrozenBothFactory, FrozenCheckFactory, FrozenHandler, FrozenMirror, FrozenMirrorFactory, FrozenValidator, HandlerManifest, ProgramId, ReconstructImpl, StringCodecNode, ValidatorManifest, ValidatorSlot, aotActivationError, beginCompilerSession, captureImpl, createAotFingerprint, createProgramId, endCompilerSession, getCompilerSession, reconstruct, setCaptureImpl };
+export { AOT_ABI, AOT_MANIFEST_FORMAT, AotFingerprint, Capture, CaptureImpl, CapturedHandler, CapturedMirror, CapturedValidator, CheckBuildResult, Compiled, CompiledProgramRegistration, CompiledSnapshot, CompilerSession, CompilerState, EMPTY_EXTERNALS, FrozenBothFactory, FrozenCheckFactory, FrozenHandler, FrozenMirror, FrozenMirrorFactory, FrozenValidator, HandlerManifest, ProgramId, ReconstructImpl, StringCodecNode, ValidatorManifest, ValidatorSlot, aotActivationError, beginCompilerSession, captureImpl, createAotFingerprint, endCompilerSession, getCompilerSession, reconstruct, setCaptureImpl };

package/dist/compile/aot.js

@@ -6,11 +6,8 @@ const require_package = require('../package.js');
 //#region src/compile/aot.ts
 const AOT_MANIFEST_FORMAT = 3;
 const AOT_ABI = `${require_package.version}:${3}`;
-const createProgramId = () => ({});
 const sharedAotFingerprint = Object.freeze({ abi: AOT_ABI });
-function createAotFingerprint() {
-	return sharedAotFingerprint;
-}
+const createAotFingerprint = () => sharedAotFingerprint;
 let activeSession;
 const newCompilerSession = () => ({ sucroseCache: /* @__PURE__ */ new Map() });
 function beginCompilerSession(app) {
@@ -41,7 +38,12 @@ function reconstruct() {
 	return reconstructImpl;
 }
 let registered;
-let claimed = false;
+/**
+* App that consumed this process's manifest, held weakly: it only has to
+* recognise a re-claim by the *same* app, and `assertUncontested` always
+* compares against a live id, so a cleared ref answers as a strong one would
+*/
+let claimed;
 let programs = /* @__PURE__ */ new WeakMap();
 const programFor = (id) => id ? programs.get(id) : void 0;
 const fingerprintMismatch = (manifest, actual) => {
@@ -54,14 +56,14 @@ const fingerprintMismatch = (manifest, actual) => {
 var Compiled = class {
 	static register(manifest) {
 		registered = manifest;
-		claimed = false;
+		claimed = void 0;
 	}
 	static claim(id, fingerprint) {
 		if (!registered || claimed) return false;
 		const manifest = registered;
 		const differences = fingerprintMismatch(manifest, fingerprint);
 		if (differences.length) throw new Error(`[elysia-aot] Registered manifest fingerprint mismatch: ${differences.join("; ")}.`);
-		claimed = true;
+		claimed = new WeakRef(id);
 		registered = void 0;
 		programs.set(id, {
 			...manifest,
@@ -69,6 +71,10 @@ var Compiled = class {
 		});
 		return true;
 	}
+	static assertUncontested(id) {
+		if (claimed === void 0 || claimed.deref() === id || isAotBuildEnv()) return;
+		throw new Error("[elysia-aot] A second Elysia app built a router in this process. An AOT build seals one app per process.");
+	}
 	static get reconstruct() {
 		return reconstructImpl;
 	}
@@ -116,7 +122,7 @@ var Compiled = class {
 	/** @internal test isolation */
 	static clear() {
 		registered = void 0;
-		claimed = false;
+		claimed = void 0;
 		programs = /* @__PURE__ */ new WeakMap();
 	}
 };
@@ -213,7 +219,6 @@ Object.defineProperty(exports, 'captureImpl', {
   }
 });
 exports.createAotFingerprint = createAotFingerprint;
-exports.createProgramId = createProgramId;
 exports.endCompilerSession = endCompilerSession;
 exports.getCompilerSession = getCompilerSession;
 exports.reconstruct = reconstruct;

package/dist/compile/aot.mjs

@@ -5,11 +5,8 @@ import { version } from "../package.mjs";
 //#region src/compile/aot.ts
 const AOT_MANIFEST_FORMAT = 3;
 const AOT_ABI = `${version}:${3}`;
-const createProgramId = () => ({});
 const sharedAotFingerprint = Object.freeze({ abi: AOT_ABI });
-function createAotFingerprint() {
-	return sharedAotFingerprint;
-}
+const createAotFingerprint = () => sharedAotFingerprint;
 let activeSession;
 const newCompilerSession = () => ({ sucroseCache: /* @__PURE__ */ new Map() });
 function beginCompilerSession(app) {
@@ -40,7 +37,12 @@ function reconstruct() {
 	return reconstructImpl;
 }
 let registered;
-let claimed = false;
+/**
+* App that consumed this process's manifest, held weakly: it only has to
+* recognise a re-claim by the *same* app, and `assertUncontested` always
+* compares against a live id, so a cleared ref answers as a strong one would
+*/
+let claimed;
 let programs = /* @__PURE__ */ new WeakMap();
 const programFor = (id) => id ? programs.get(id) : void 0;
 const fingerprintMismatch = (manifest, actual) => {
@@ -53,14 +55,14 @@ const fingerprintMismatch = (manifest, actual) => {
 var Compiled = class {
 	static register(manifest) {
 		registered = manifest;
-		claimed = false;
+		claimed = void 0;
 	}
 	static claim(id, fingerprint) {
 		if (!registered || claimed) return false;
 		const manifest = registered;
 		const differences = fingerprintMismatch(manifest, fingerprint);
 		if (differences.length) throw new Error(`[elysia-aot] Registered manifest fingerprint mismatch: ${differences.join("; ")}.`);
-		claimed = true;
+		claimed = new WeakRef(id);
 		registered = void 0;
 		programs.set(id, {
 			...manifest,
@@ -68,6 +70,10 @@ var Compiled = class {
 		});
 		return true;
 	}
+	static assertUncontested(id) {
+		if (claimed === void 0 || claimed.deref() === id || isAotBuildEnv()) return;
+		throw new Error("[elysia-aot] A second Elysia app built a router in this process. An AOT build seals one app per process.");
+	}
 	static get reconstruct() {
 		return reconstructImpl;
 	}
@@ -115,7 +121,7 @@ var Compiled = class {
 	/** @internal test isolation */
 	static clear() {
 		registered = void 0;
-		claimed = false;
+		claimed = void 0;
 		programs = /* @__PURE__ */ new WeakMap();
 	}
 };
@@ -197,4 +203,4 @@ function setCaptureImpl(impl) {
 }
 
 //#endregion
-export { AOT_ABI, AOT_MANIFEST_FORMAT, Capture, Compiled, CompilerState, EMPTY_EXTERNALS, aotActivationError, beginCompilerSession, captureImpl, createAotFingerprint, createProgramId, endCompilerSession, getCompilerSession, reconstruct, setCaptureImpl };
+export { AOT_ABI, AOT_MANIFEST_FORMAT, Capture, Compiled, CompilerState, EMPTY_EXTERNALS, aotActivationError, beginCompilerSession, captureImpl, createAotFingerprint, endCompilerSession, getCompilerSession, reconstruct, setCaptureImpl };

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

@@ -1,6 +1,6 @@
 import { TraceEvent } from "../../trace.js";
-import { AnyLocalHook, MaybeArray } from "../../types.js";
 import { CompactBeforeHandlePrefix } from "../../utils.js";
+import { AnyLocalHook, MaybeArray } from "../../types.js";
 import { CompiledCookieConfig } from "../../cookie/config.js";
 import { AnyElysia } from "../../base.js";
 import { ElysiaAdapter } from "../../adapter/index.js";

package/dist/compile/handler/descriptor.js

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_utils = require('../../utils.js');
+const require_cookie_crypto = require('../../cookie/crypto.js');
 const require_compile_aot = require('../aot.js');
 const require_generation = require('../../generation.js');
-const require_cookie_crypto = require('../../cookie/crypto.js');
 const require_cookie_config = require('../../cookie/config.js');
 const require_compile_utils = require('../utils.js');
 const require_compile_jit_probe = require('../jit-probe.js');

package/dist/compile/handler/descriptor.mjs

@@ -1,7 +1,7 @@
 import { isNotEmpty } from "../../utils.mjs";
+import { hasSyncHmac } from "../../cookie/crypto.mjs";
 import { Capture } from "../aot.mjs";
 import { frozenRootOf, resolvedTraceOf, traceCapabilityRequired } from "../../generation.mjs";
-import { hasSyncHmac } from "../../cookie/crypto.mjs";
 import { compileCookieConfig } from "../../cookie/config.mjs";
 import { isAsyncFunction, isAsyncLifecycle, mayReturnPromise } from "../utils.mjs";
 import { JITProbe } from "../jit-probe.mjs";

package/dist/compile/handler/frozen-validator.d.ts

@@ -11,6 +11,7 @@ interface SlotCheckClean {
   decode?: (value: unknown) => unknown;
 }
 declare function isCompactDiagnosable(schema: any): boolean;
+declare function isCompactWalkable(schema: any): boolean;
 declare class FrozenSlotValidator {
   #private;
   isAsync: boolean;
@@ -36,4 +37,4 @@ declare function mergeSchemasAllStandard(schemas: Array<Record<string, unknown>>
 declare function buildFrozenRouteValidator(hook: AnyLocalHook, root: AnyElysia, method: HTTPMethod, path: string): FrozenRouteValidatorShape | undefined;
 declare function isCapturedBridgeFree(c: CapturedValidator, schema: unknown, coerced?: unknown): boolean;
 //#endregion
-export { buildFrozenRouteValidator, isBridgeNotInitialized, isCapturedBridgeFree, isCompactDiagnosable, isStandardSchema, mergeSchemasAllStandard };
+export { buildFrozenRouteValidator, isBridgeNotInitialized, isCapturedBridgeFree, isCompactDiagnosable, isCompactWalkable, isStandardSchema, mergeSchemasAllStandard };

package/dist/compile/handler/frozen-validator.js

@@ -55,17 +55,30 @@ const typeError = (schema, instancePath, schemaPath) => ({
 **/
 function walkCompactError(schema, value, instancePath, schemaPath) {
 	if (!schema || typeof schema !== "object") return;
+	const elyTyp = schema["~elyTyp"];
+	if (schema.anyOf && (elyTyp === require_type_constants.ELYSIA_TYPES.ObjectString || elyTyp === require_type_constants.ELYSIA_TYPES.ArrayString)) {
+		let decoded = value;
+		if (typeof value === "string") try {
+			decoded = JSON.parse(value);
+		} catch {
+			return;
+		}
+		else if (value === void 0) return;
+		return walkCompactError(schema.anyOf[0], decoded, instancePath, `${schemaPath}/anyOf/0`);
+	}
 	const type = schema.type;
 	if (type === "object") {
 		if (typeof value !== "object" || value === null || Array.isArray(value)) return typeError(schema, instancePath, schemaPath);
 		const required = schema.required;
 		if (Array.isArray(required)) {
-			for (const key of required) if (!(key in value)) return {
+			let missing;
+			for (const key of required) if (!(key in value)) (missing ??= []).push(key);
+			if (missing) return {
 				keyword: "required",
 				schemaPath,
 				instancePath,
-				params: { requiredProperties: [key] },
-				message: `must have required properties ${key}`
+				params: { requiredProperties: missing },
+				message: `must have required properties ${missing.join(", ")}`
 			};
 		}
 		const properties = schema.properties;
@@ -121,6 +134,22 @@ function isCompactDiagnosable(schema) {
 	if (type === "array") return isCompactDiagnosable(schema.items);
 	return type === "string" || type === "number" || type === "integer" || type === "boolean" || type === "null";
 }
+function isCompactWalkable(schema) {
+	if (!schema || typeof schema !== "object") return false;
+	const elyTyp = schema["~elyTyp"];
+	if (schema.anyOf && (elyTyp === require_type_constants.ELYSIA_TYPES.ObjectString || elyTyp === require_type_constants.ELYSIA_TYPES.ArrayString)) return isCompactWalkable(schema.anyOf[0]);
+	if (schema.anyOf || schema.oneOf || schema.allOf) return false;
+	const type = schema.type;
+	if (type === "object") {
+		const properties = schema.properties;
+		if (properties) {
+			for (const key in properties) if (!isCompactWalkable(properties[key])) return false;
+		}
+		return true;
+	}
+	if (type === "array") return isCompactWalkable(schema.items);
+	return type === "string" || type === "number" || type === "integer" || type === "boolean" || type === "null";
+}
 var FrozenSlotValidator = class {
 	#check;
 	#clean;
@@ -315,5 +344,6 @@ exports.buildFrozenRouteValidator = buildFrozenRouteValidator;
 exports.isBridgeNotInitialized = isBridgeNotInitialized;
 exports.isCapturedBridgeFree = isCapturedBridgeFree;
 exports.isCompactDiagnosable = isCompactDiagnosable;
+exports.isCompactWalkable = isCompactWalkable;
 exports.isStandardSchema = isStandardSchema;
 exports.mergeSchemasAllStandard = mergeSchemasAllStandard;

package/dist/compile/handler/frozen-validator.mjs

@@ -54,17 +54,30 @@ const typeError = (schema, instancePath, schemaPath) => ({
 **/
 function walkCompactError(schema, value, instancePath, schemaPath) {
 	if (!schema || typeof schema !== "object") return;
+	const elyTyp = schema["~elyTyp"];
+	if (schema.anyOf && (elyTyp === ELYSIA_TYPES.ObjectString || elyTyp === ELYSIA_TYPES.ArrayString)) {
+		let decoded = value;
+		if (typeof value === "string") try {
+			decoded = JSON.parse(value);
+		} catch {
+			return;
+		}
+		else if (value === void 0) return;
+		return walkCompactError(schema.anyOf[0], decoded, instancePath, `${schemaPath}/anyOf/0`);
+	}
 	const type = schema.type;
 	if (type === "object") {
 		if (typeof value !== "object" || value === null || Array.isArray(value)) return typeError(schema, instancePath, schemaPath);
 		const required = schema.required;
 		if (Array.isArray(required)) {
-			for (const key of required) if (!(key in value)) return {
+			let missing;
+			for (const key of required) if (!(key in value)) (missing ??= []).push(key);
+			if (missing) return {
 				keyword: "required",
 				schemaPath,
 				instancePath,
-				params: { requiredProperties: [key] },
-				message: `must have required properties ${key}`
+				params: { requiredProperties: missing },
+				message: `must have required properties ${missing.join(", ")}`
 			};
 		}
 		const properties = schema.properties;
@@ -120,6 +133,22 @@ function isCompactDiagnosable(schema) {
 	if (type === "array") return isCompactDiagnosable(schema.items);
 	return type === "string" || type === "number" || type === "integer" || type === "boolean" || type === "null";
 }
+function isCompactWalkable(schema) {
+	if (!schema || typeof schema !== "object") return false;
+	const elyTyp = schema["~elyTyp"];
+	if (schema.anyOf && (elyTyp === ELYSIA_TYPES.ObjectString || elyTyp === ELYSIA_TYPES.ArrayString)) return isCompactWalkable(schema.anyOf[0]);
+	if (schema.anyOf || schema.oneOf || schema.allOf) return false;
+	const type = schema.type;
+	if (type === "object") {
+		const properties = schema.properties;
+		if (properties) {
+			for (const key in properties) if (!isCompactWalkable(properties[key])) return false;
+		}
+		return true;
+	}
+	if (type === "array") return isCompactWalkable(schema.items);
+	return type === "string" || type === "number" || type === "integer" || type === "boolean" || type === "null";
+}
 var FrozenSlotValidator = class {
 	#check;
 	#clean;
@@ -310,4 +339,4 @@ function isCapturedBridgeFree(c, schema, coerced = schema) {
 }
 
 //#endregion
-export { buildFrozenRouteValidator, isBridgeNotInitialized, isCapturedBridgeFree, isCompactDiagnosable, isStandardSchema, mergeSchemasAllStandard };
+export { buildFrozenRouteValidator, isBridgeNotInitialized, isCapturedBridgeFree, isCompactDiagnosable, isCompactWalkable, isStandardSchema, mergeSchemasAllStandard };

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

@@ -1,5 +1,5 @@
-import { AnyLocalHook, CompiledHandler, InternalRoute } from "../../types.js";
 import { ChainNode } from "../../utils.js";
+import { AnyLocalHook, CompiledHandler, InternalRoute } from "../../types.js";
 import { AnyElysia } from "../../base.js";
 import { setCaptureHeaderShorthand } from "./jit.js";
 
@@ -12,8 +12,8 @@ declare function resolveWSLocalHook(scope: AnyElysia, hook: Partial<AnyLocalHook
  */
 declare function clearHandlerAnalysisCaches(root: AnyElysia): void;
 declare const localMacroRoot: (instance: AnyElysia, root: AnyElysia) => AnyElysia;
-declare function buildNativeStaticResponse([,, handler, instance, localHook, appHook, inheritedChain, macroScope]: InternalRoute, root: AnyElysia): Response | undefined;
+declare function buildNativeStaticResponse(route: InternalRoute, root: AnyElysia): Response | undefined;
 declare function composeRouteHook(instance: AnyElysia, localHook: Partial<AnyLocalHook> | undefined, appHook: ChainNode | undefined, inheritedChain: ChainNode | undefined, root: AnyElysia, macroScope?: AnyElysia): AnyLocalHook | undefined;
-declare function compileHandler([_method, path, handler, instance, localHook, appHook, inheritedChain, macroScope]: InternalRoute, root: AnyElysia, precomputedStatic?: Response): CompiledHandler;
+declare function compileHandler(route: InternalRoute, root: AnyElysia, precomputedStatic?: Response): CompiledHandler;
 //#endregion
 export { buildNativeStaticResponse, clearHandlerAnalysisCaches, compileHandler, composeRouteHook, localMacroRoot, resolveLocalHook, resolveWSLocalHook, setCaptureHeaderShorthand };

package/dist/compile/handler/index.js

@@ -198,10 +198,10 @@ function resolveChainNode(root, node) {
 	}
 	return resolved;
 }
-const chainResolver = (root) => {
+function chainResolver(root) {
 	const frozenRoot = require_generation.frozenRootOf(root);
 	return frozenRoot["~ext"]?.macro || frozenRoot["~scopeChildren"] ? (node) => resolveChainNode(root, node) : void 0;
-};
+}
 const localMacroRoot = (instance, root) => instance !== root && instance["~scopeChild"] === true && require_generation.frozenRootOf(instance)["~ext"]?.macro ? instance : root;
 function composeRootHook(root, inheritedChain) {
 	const resolve = chainResolver(root);
@@ -211,7 +211,8 @@ function composeRootHook(root, inheritedChain) {
 	if (!locals) return inherited;
 	return require_utils.mergeHook(inherited, locals);
 }
-function buildNativeStaticResponse([, , handler, instance, localHook, appHook, inheritedChain, macroScope], root) {
+function buildNativeStaticResponse(route, root) {
+	const [, , handler, instance, localHook, appHook, inheritedChain, macroScope] = route;
 	if (typeof handler === "function" || handler instanceof Error || handler instanceof Promise) return;
 	const frozenRoot = require_generation.frozenRootOf(root);
 	const adapter = frozenRoot["~config"]?.adapter ?? require_adapter_constants.defaultAdapter;
@@ -273,7 +274,8 @@ function isContextFreeHandler(handler) {
 	const source = Function.prototype.toString.call(handler);
 	return isBareArrow.test(source) && !isSucroseOpaque.test(source);
 }
-function compileHandler([_method, path, handler, instance, localHook, appHook, inheritedChain, macroScope], root, precomputedStatic) {
+function compileHandler(route, root, precomputedStatic) {
+	let [_method, path, handler, instance, localHook, appHook, inheritedChain, macroScope] = route;
 	const frozenRoot = require_generation.frozenRootOf(root);
 	const adapter = frozenRoot["~config"]?.adapter ?? require_adapter_constants.defaultAdapter;
 	const method = _method;