elysia 2.0.0-exp.51 → 2.0.0-exp.52

package/dist/adapter/bun/index.js

@@ -4,9 +4,9 @@ const require_constants = require('../../constants.js');
 const require_utils = require('../../utils.js');
 const require_adapter_web_standard_index = require('../web-standard/index.js');
 const require_generation = require('../../generation.js');
+const require_adapter_origin = require('../origin.js');
 const require_compile_handler_index = require('../../compile/handler/index.js');
 const require_route_table = require('../../route-table.js');
-const require_adapter_origin = require('../origin.js');
 
 //#region src/adapter/bun/index.ts
 /**
@@ -15,9 +15,11 @@ const require_adapter_origin = require('../origin.js');
 * always run before the next request comes in
 * @see ../origin.ts
 *
-* Publish the request `Bun.serve` handed us so `createFetchHandler` can prove,
-* before its first suspension, that it holds the untouched original and may
-* defer materializing `request.signal`
+* Publish the request `Bun.serve` handed us so the pipeline can prove, before
+* its first suspension, that it holds the untouched original and may defer
+* materializing `request.signal`. The proof happens in `createFetchHandler`'s
+* prologue when there is a request hook, and at the compiled route's entry
+* probe otherwise — both inside the same synchronous frame.
 *
 * `finally` runs on the synchronous return of `fetch` (the returned promise is
 * not awaited), so the slot is live only for the handler's synchronous prologue.

package/dist/adapter/bun/index.mjs

@@ -3,9 +3,9 @@ import { isDynamicRegex, needEncodeRegex } from "../../constants.mjs";
 import { flattenChain, getLoosePath, nullObject } from "../../utils.mjs";
 import { WebStandardAdapter } from "../web-standard/index.mjs";
 import { frozenRootOf, resolvedWsOf } from "../../generation.mjs";
+import { origin } from "../origin.mjs";
 import { buildNativeStaticResponse } from "../../compile/handler/index.mjs";
 import { routeRow } from "../../route-table.mjs";
-import { origin } from "../origin.mjs";
 
 //#region src/adapter/bun/index.ts
 /**
@@ -14,9 +14,11 @@ import { origin } from "../origin.mjs";
 * always run before the next request comes in
 * @see ../origin.ts
 *
-* Publish the request `Bun.serve` handed us so `createFetchHandler` can prove,
-* before its first suspension, that it holds the untouched original and may
-* defer materializing `request.signal`
+* Publish the request `Bun.serve` handed us so the pipeline can prove, before
+* its first suspension, that it holds the untouched original and may defer
+* materializing `request.signal`. The proof happens in `createFetchHandler`'s
+* prologue when there is a request hook, and at the compiled route's entry
+* probe otherwise — both inside the same synchronous frame.
 *
 * `finally` runs on the synchronous return of `fetch` (the returned promise is
 * not awaited), so the slot is live only for the handler's synchronous prologue.

package/dist/adapter/origin.d.ts

@@ -11,7 +11,9 @@
  * and therefore must be observed synchronously.
  *
  * The Bun adapter publishes the untouched original here for the *synchronous*
- * prologue of `app.fetch` and clears it in `finally`, so the window closes
+ * prologue of `app.fetch` and, on the lane where `fetch` has no request hook
+ * to run, for the compiled route's own entry probe, which is still inside that
+ * same synchronous frame, then clears it in `finally`, so the window closes
  * before the first suspension and cannot leak across concurrent requests.
  * A `.wrap()` HOC that replaces the request or defers calling `next()` past a
  * microtask simply misses the window, fetch handler falls back to eager check
@@ -23,7 +25,9 @@
  * JavaScript only ever does ONE thing at a time. When a request comes in, the
  * adapter writes its name on the whiteboard (`origin.request = request`),
  * walks it down the hall (`fetch(request)` the synchronous part, where the
- * one and only identity check happens), and erases the whiteboard (`finally`)
+ * one and only identity check happens, in `fetch`'s prologue, or at the
+ * compiled route's entry when `fetch` had no hook to run first), and erases
+ * the whiteboard `finally`
  * all in one uninterruptible turn. The next request's turn CANNOT start
  * until this turn is completely finished, because that is how the event loop
  * works: run-to-completion, no preemption. So request B can never see request

package/dist/adapter/origin.js

@@ -13,7 +13,9 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 * and therefore must be observed synchronously.
 *
 * The Bun adapter publishes the untouched original here for the *synchronous*
-* prologue of `app.fetch` and clears it in `finally`, so the window closes
+* prologue of `app.fetch` and, on the lane where `fetch` has no request hook
+* to run, for the compiled route's own entry probe, which is still inside that
+* same synchronous frame, then clears it in `finally`, so the window closes
 * before the first suspension and cannot leak across concurrent requests.
 * A `.wrap()` HOC that replaces the request or defers calling `next()` past a
 * microtask simply misses the window, fetch handler falls back to eager check
@@ -25,7 +27,9 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 * JavaScript only ever does ONE thing at a time. When a request comes in, the
 * adapter writes its name on the whiteboard (`origin.request = request`),
 * walks it down the hall (`fetch(request)` the synchronous part, where the
-* one and only identity check happens), and erases the whiteboard (`finally`)
+* one and only identity check happens, in `fetch`'s prologue, or at the
+* compiled route's entry when `fetch` had no hook to run first), and erases
+* the whiteboard `finally`
 * all in one uninterruptible turn. The next request's turn CANNOT start
 * until this turn is completely finished, because that is how the event loop
 * works: run-to-completion, no preemption. So request B can never see request

package/dist/adapter/origin.mjs

@@ -11,7 +11,9 @@
 * and therefore must be observed synchronously.
 *
 * The Bun adapter publishes the untouched original here for the *synchronous*
-* prologue of `app.fetch` and clears it in `finally`, so the window closes
+* prologue of `app.fetch` and, on the lane where `fetch` has no request hook
+* to run, for the compiled route's own entry probe, which is still inside that
+* same synchronous frame, then clears it in `finally`, so the window closes
 * before the first suspension and cannot leak across concurrent requests.
 * A `.wrap()` HOC that replaces the request or defers calling `next()` past a
 * microtask simply misses the window, fetch handler falls back to eager check
@@ -23,7 +25,9 @@
 * JavaScript only ever does ONE thing at a time. When a request comes in, the
 * adapter writes its name on the whiteboard (`origin.request = request`),
 * walks it down the hall (`fetch(request)` the synchronous part, where the
-* one and only identity check happens), and erases the whiteboard (`finally`)
+* one and only identity check happens, in `fetch`'s prologue, or at the
+* compiled route's entry when `fetch` had no hook to run first), and erases
+* the whiteboard `finally`
 * all in one uninterruptible turn. The next request's turn CANNOT start
 * until this turn is completely finished, because that is how the event loop
 * works: run-to-completion, no preemption. So request B can never see request

package/dist/compile/handler/jit.js

@@ -221,7 +221,8 @@ function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapt
 	let code = `${isAsync ? "async " : ""}function route(c){\n`;
 	if (abortOn) {
 		link(require_handler_utils.emptyResponse, "emp");
-		code += abortCheck();
+		link(require_compile_handler_utils.armEntryAbort, "ea");
+		code += `if(ea(c))return emp.clone()\n`;
 	}
 	if ((hasAfterResponse || hasTrace) && !syncAfterResponse) code += "let _stl\n";
 	if (asyncCookieSign) code += "let _sg\n";

package/dist/compile/handler/jit.mjs

@@ -11,7 +11,7 @@ import { resolvedTraceOf, traceCapabilityRequired } from "../../generation.mjs";
 import { buildCookieJar, parseCookieRaw, parseCookieRawDeferred, parseCookieRawLazy, parseCookieRawSigned, parseCookieRawSync, signCookieValues } from "../../cookie/utils.mjs";
 import { isAsyncFunction } from "../utils.mjs";
 import { emptyResponse, finalizeRouteError, forwardError } from "../../handler/utils.mjs";
-import { cloneResponse, getQueryParseChannels, hasRequestBody, mapAfterHandle, mapAfterResponse, mapBeforeHandle, mapError, mapMapResponse, mapTransform, runBeforeHandlePrefix, runBeforeHandlePrefixAsync } from "./utils.mjs";
+import { armEntryAbort, cloneResponse, getQueryParseChannels, hasRequestBody, mapAfterHandle, mapAfterResponse, mapBeforeHandle, mapError, mapMapResponse, mapTransform, runBeforeHandlePrefix, runBeforeHandlePrefixAsync } from "./utils.mjs";
 import { JITProbe } from "../jit-probe.mjs";
 
 //#region src/compile/handler/jit.ts
@@ -220,7 +220,8 @@ function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapt
 	let code = `${isAsync ? "async " : ""}function route(c){\n`;
 	if (abortOn) {
 		link(emptyResponse, "emp");
-		code += abortCheck();
+		link(armEntryAbort, "ea");
+		code += `if(ea(c))return emp.clone()\n`;
 	}
 	if ((hasAfterResponse || hasTrace) && !syncAfterResponse) code += "let _stl\n";
 	if (asyncCookieSign) code += "let _sg\n";

package/dist/compile/handler/params.js

@@ -30,6 +30,7 @@ const HANDLER_PARAMS = {
 	rdc: () => require_compile_handler_utils.replaceDeriveContext,
 	ise: () => require_error.internalServerErrorResponse,
 	emp: () => require_handler_utils.emptyResponse,
+	ea: () => require_compile_handler_utils.armEntryAbort,
 	isprod: () => require_universal_is_production.isProduction,
 	verr: () => require_error.ValidationError,
 	tee: () => require_adapter_utils.tee,

package/dist/compile/handler/params.mjs

@@ -5,7 +5,7 @@ import { materializeSetHeaders, normalizeContentType, tee } from "../../adapter/
 import { parseQueryFromURL } from "../../parse-query.mjs";
 import { buildCookieJar, parseCookieRaw, parseCookieRawDeferred, parseCookieRawLazy, parseCookieRawSigned, parseCookieRawSync, signCookieValues } from "../../cookie/utils.mjs";
 import { emptyResponse, finalizeRouteError, forwardError } from "../../handler/utils.mjs";
-import { cloneResponse, getQueryParseChannels, hasRequestBody, replaceDeriveContext, runBeforeHandlePrefix } from "./utils.mjs";
+import { armEntryAbort, cloneResponse, getQueryParseChannels, hasRequestBody, replaceDeriveContext, runBeforeHandlePrefix } from "./utils.mjs";
 
 //#region src/compile/handler/params.ts
 /** @internal exported for test/aot/param-descriptor.test.ts */
@@ -29,6 +29,7 @@ const HANDLER_PARAMS = {
 	rdc: () => replaceDeriveContext,
 	ise: () => internalServerErrorResponse,
 	emp: () => emptyResponse,
+	ea: () => armEntryAbort,
 	isprod: () => isProduction,
 	verr: () => ValidationError,
 	tee: () => tee,

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

@@ -13,6 +13,14 @@ interface TraceReporter {
 }
 declare function cloneResponse(r: unknown): unknown;
 declare function hasRequestBody(request: Request): boolean;
+/**
+ * Route-entry abort probe. Mirrors `createFetchHandler`'s `armEager`, but is
+ * paid only by routes that can actually observe an abort, so a hook-less
+ * route never materializes `request.signal` on any lane.
+ *
+ * @see `../../adapter/origin` for the provenance channel
+ */
+declare function armEntryAbort(context: any): any;
 declare const mapTransform: (event: MaybeArray<TransformHandler<any, any, undefined, "local">>, rest?: [isAsync: boolean, report?: TraceReporter | undefined] | undefined, abortGuard?: string) => string;
 declare function extractDeriveKeys(fn: Function): string[] | null;
 declare function replaceDeriveContext(context: any, derivative: any): any;
@@ -34,4 +42,4 @@ interface QueryWalkState {
 }
 declare function getQueryParseChannels(querySchema: any): QueryWalkState | undefined;
 //#endregion
-export { Link, TraceReporter, cloneResponse, deriveModes, emptyResponse, extractDeriveKeys, getQueryParseChannels, hasRequestBody, mapAfterHandle, mapAfterResponse, mapBeforeHandle, mapError, mapMapResponse, mapTransform, replaceDeriveContext, runBeforeHandlePrefix, runBeforeHandlePrefixAsync };
+export { Link, TraceReporter, armEntryAbort, cloneResponse, deriveModes, emptyResponse, extractDeriveKeys, getQueryParseChannels, hasRequestBody, mapAfterHandle, mapAfterResponse, mapBeforeHandle, mapError, mapMapResponse, mapTransform, replaceDeriveContext, runBeforeHandlePrefix, runBeforeHandlePrefixAsync };

package/dist/compile/handler/utils.js

@@ -5,6 +5,7 @@ const require_adapter_skip_clone = require('../../adapter/skip-clone.js');
 const require_error = require('../../error.js');
 const require_compile_utils = require('../utils.js');
 const require_handler_utils = require('../../handler/utils.js');
+const require_adapter_origin = require('../../adapter/origin.js');
 const require_compile_lexer = require('../lexer.js');
 
 //#region src/compile/handler/utils.ts
@@ -27,6 +28,19 @@ function hasRequestBody(request) {
 	if (request.headers.get("transfer-encoding") !== null) return true;
 	return request.body != null;
 }
+/**
+* Route-entry abort probe. Mirrors `createFetchHandler`'s `armEager`, but is
+* paid only by routes that can actually observe an abort, so a hook-less
+* route never materializes `request.signal` on any lane.
+*
+* @see `../../adapter/origin` for the provenance channel
+*/
+function armEntryAbort(context) {
+	const sig = context["~sig"];
+	if (sig !== void 0) return sig.aborted === true;
+	if (context.request === require_adapter_origin.origin.request) return false;
+	return (context["~sig"] = context.request.signal).aborted;
+}
 const trace = (report, fn) => report?.resolveChild(childName(fn)) ?? noTrace;
 const toArray = (v) => Array.isArray(v) ? v : [v];
 const mapTransform = /* @__PURE__ */ map((i, fn, [isAsync, report]) => {
@@ -481,6 +495,7 @@ const Await = (fn) => require_compile_utils.isAsyncFunction(fn) ? "await " : "";
 const awaitGuard = (fn, isAsync, target) => isAsync && !require_compile_utils.isAsyncFunction(fn) ? `if(${target} instanceof Promise)${target}=await ${target}\n` : "";
 
 //#endregion
+exports.armEntryAbort = armEntryAbort;
 exports.cloneResponse = cloneResponse;
 exports.deriveModes = deriveModes;
 exports.emptyResponse = require_handler_utils.emptyResponse;

package/dist/compile/handler/utils.mjs

@@ -4,6 +4,7 @@ import { skipClone } from "../../adapter/skip-clone.mjs";
 import { ElysiaStatus } from "../../error.mjs";
 import { isAsyncFunction } from "../utils.mjs";
 import { emptyResponse } from "../../handler/utils.mjs";
+import { origin } from "../../adapter/origin.mjs";
 import { isIdentChar, isSpace, skipString } from "../lexer.mjs";
 
 //#region src/compile/handler/utils.ts
@@ -26,6 +27,19 @@ function hasRequestBody(request) {
 	if (request.headers.get("transfer-encoding") !== null) return true;
 	return request.body != null;
 }
+/**
+* Route-entry abort probe. Mirrors `createFetchHandler`'s `armEager`, but is
+* paid only by routes that can actually observe an abort, so a hook-less
+* route never materializes `request.signal` on any lane.
+*
+* @see `../../adapter/origin` for the provenance channel
+*/
+function armEntryAbort(context) {
+	const sig = context["~sig"];
+	if (sig !== void 0) return sig.aborted === true;
+	if (context.request === origin.request) return false;
+	return (context["~sig"] = context.request.signal).aborted;
+}
 const trace = (report, fn) => report?.resolveChild(childName(fn)) ?? noTrace;
 const toArray = (v) => Array.isArray(v) ? v : [v];
 const mapTransform = /* @__PURE__ */ map((i, fn, [isAsync, report]) => {
@@ -480,4 +494,4 @@ const Await = (fn) => isAsyncFunction(fn) ? "await " : "";
 const awaitGuard = (fn, isAsync, target) => isAsync && !isAsyncFunction(fn) ? `if(${target} instanceof Promise)${target}=await ${target}\n` : "";
 
 //#endregion
-export { cloneResponse, deriveModes, emptyResponse, extractDeriveKeys, getQueryParseChannels, hasRequestBody, mapAfterHandle, mapAfterResponse, mapBeforeHandle, mapError, mapMapResponse, mapTransform, replaceDeriveContext, runBeforeHandlePrefix, runBeforeHandlePrefixAsync };
+export { armEntryAbort, cloneResponse, deriveModes, emptyResponse, extractDeriveKeys, getQueryParseChannels, hasRequestBody, mapAfterHandle, mapAfterResponse, mapBeforeHandle, mapError, mapMapResponse, mapTransform, replaceDeriveContext, runBeforeHandlePrefix, runBeforeHandlePrefixAsync };

package/dist/compile/lexer.d.ts

@@ -1,5 +1,5 @@
 //#region src/compile/lexer.d.ts
-declare const isSpace: (ch: string) => ch is " " | "\n" | "\t" | "\r";
+declare const isSpace: (ch: string) => ch is "\n" | " " | "\t" | "\r";
 declare const isIdentChar: (ch: string) => boolean;
 declare const isIdentCharCode: (code: number) => boolean;
 declare function skipString(src: string, start: number): number;

package/dist/context.d.ts

@@ -11,7 +11,7 @@ import { AnyElysia } from "./base.js";
 declare function createBaseContext(app: AnyElysia): any;
 declare function clearContextCache(): void;
 declare function createContext(app: AnyElysia): new (request: Request) => Context;
-type ContextBase<in out Route extends RouteSchema, in out Singleton extends SingletonBase> = {
+interface ContextBase<in out Route extends RouteSchema, in out Singleton extends SingletonBase> {
   server: Server | null;
   redirect: redirect;
   set: {
@@ -48,7 +48,7 @@ type ContextBase<in out Route extends RouteSchema, in out Singleton extends Sing
   rid?: string;
   request: Request;
   store: Singleton['store'];
-};
+}
 type ErrorContext<in out Route extends RouteSchema = {}, in out Singleton extends SingletonBase = DefaultSingleton, Path extends string | undefined = undefined> = Prettify<{
   body: Route['body'];
   query: undefined extends Route['query'] ? Record<string, string | undefined> : Route['query'];

package/dist/handler/fetch.js

@@ -304,7 +304,6 @@ function createFetchHandler(app) {
 	}
 	return (request, server) => {
 		const context = new Context(request);
-		if (abortSignal && request !== require_adapter_origin.origin.request) context["~sig"] = request.signal;
 		const path = extractPath(request.url, context, pathStart);
 		context.server = server ?? null;
 		const method = request.method;

package/dist/handler/fetch.mjs

@@ -302,7 +302,6 @@ function createFetchHandler(app) {
 	}
 	return (request, server) => {
 		const context = new Context(request);
-		if (abortSignal && request !== origin.request) context["~sig"] = request.signal;
 		const path = extractPath(request.url, context, pathStart);
 		context.server = server ?? null;
 		const method = request.method;

package/dist/package.js

@@ -1,6 +1,6 @@
 
 //#region package.json
-var version = "2.0.0-exp.51";
+var version = "2.0.0-exp.52";
 
 //#endregion
 Object.defineProperty(exports, 'version', {

package/dist/package.mjs

@@ -1,5 +1,5 @@
 //#region package.json
-var version = "2.0.0-exp.51";
+var version = "2.0.0-exp.52";
 
 //#endregion
 export { version };

package/dist/type/bridge.d.ts

@@ -1,17 +1,17 @@
-import { Intersect as Intersect$1 } from "./elysia/intersect.js";
+import { Intersect as Intersect$2 } from "./elysia/intersect.js";
 import { hasTypes as hasTypes$1 } from "./utils.js";
 import { TypeBoxValidatorCache as TypeBoxValidatorCache$1, mayHaveFileType as mayHaveFileType$1 } from "./validator/validator-cache.js";
 import { TypeBoxValidator as TypeBoxValidator$1 } from "./validator/index.js";
 import { applyCoercions as applyCoercions$1, coerceBody as coerceBody$1, coerceFormData as coerceFormData$1, coerceQuery as coerceQuery$1, coerceRoot as coerceRoot$1, coerceStringToStructure as coerceStringToStructure$1 } from "./coerce.js";
 import { Ref as Ref$1, TAny, TSchema } from "typebox/type";
 import { Compile as Compile$1 } from "typebox/compile";
-import { Check as Check$1, Clone as Clone$1, Create as Create$1, Decode as Decode$1, Default as Default$1, HasCodec as HasCodec$1 } from "typebox/value";
+import { Check as Check$1, Clone as Clone$1, Create as Create$1, Decode as Decode$2, Default as Default$1, HasCodec as HasCodec$1 } from "typebox/value";
 
 //#region src/type/bridge.d.ts
 interface TypeboxModule {
   Compile: typeof Compile$1;
   Create: typeof Create$1;
-  Decode: typeof Decode$1;
+  Decode: typeof Decode$2;
   applyCoercions: typeof applyCoercions$1;
   TypeBoxValidator: TypeBoxValidator$1;
   TypeBoxValidatorCache: TypeBoxValidatorCache$1;
@@ -23,7 +23,7 @@ interface TypeboxModule {
   hasTypes: typeof hasTypes$1;
   mayHaveFileType: typeof mayHaveFileType$1;
   HasCodec: typeof HasCodec$1;
-  Intersect: typeof Intersect$1;
+  Intersect: typeof Intersect$2;
   Default: typeof Default$1;
   Ref: typeof Ref$1;
   Clone: typeof Clone$1;
@@ -31,7 +31,7 @@ interface TypeboxModule {
 }
 declare let Compile: typeof Compile$1;
 declare let Create: typeof Create$1;
-declare let Decode: typeof Decode$1;
+declare let Decode: typeof Decode$2;
 declare let applyCoercions: typeof applyCoercions$1;
 declare let TypeBoxValidator: TypeBoxValidator$1;
 type TypeBoxValidator<T extends TSchema = TAny> = TypeBoxValidator$1<T>;
@@ -45,7 +45,7 @@ declare let coerceBody: typeof coerceBody$1;
 declare let hasTypes: typeof hasTypes$1;
 declare let mayHaveFileType: typeof mayHaveFileType$1;
 declare let HasCodec: typeof HasCodec$1;
-declare let Intersect: typeof Intersect$1;
+declare let Intersect: typeof Intersect$2;
 declare let Default: typeof Default$1;
 declare let Ref: typeof Ref$1;
 declare let Clone: typeof Clone$1;

package/dist/type/constants.d.ts

@@ -17,7 +17,7 @@ declare const ELYSIA_TYPES: {
   readonly NoValidate: 15;
 };
 type ELYSIA_TYPES = typeof ELYSIA_TYPES;
-declare const primitiveElysiaTypes: Set<2 | 1 | 6 | 3 | 10 | 11 | 13 | 14>;
+declare const primitiveElysiaTypes: Set<1 | 2 | 6 | 3 | 10 | 11 | 13 | 14>;
 declare const noEnumerable: {
   readonly enumerable: false;
 };

package/dist/type/validator/index.d.ts

@@ -2,8 +2,8 @@ import { MaybePromise } from "../../types.js";
 import { Validator as Validator$1, ValidatorOptions } from "../../validator/index.js";
 import { TypeBoxValidatorCache, mayHaveFileType } from "./validator-cache.js";
 import { Static, StaticDecode, StaticEncode, TAny, TSchema } from "typebox/type";
-import { TLocalizedValidationError } from "typebox/error";
 import { Validator } from "typebox/schema";
+import { TLocalizedValidationError } from "typebox/error";
 
 //#region src/type/validator/index.d.ts
 declare function shallowMergeObjects(members: any[]): TSchema | null;

package/dist/types.d.ts

@@ -9,8 +9,8 @@ import { Context, ErrorContext, LifecycleContext, PreContext } from "./context.j
 import { AnySchema, StandardSchemaV1Like, TypeBoxSchema } from "./type/types.js";
 import { AnyElysia, Elysia } from "./base.js";
 import { ElysiaAdapter } from "./adapter/index.js";
-import { Static, StaticDecode, StaticEncode, TIntersect, TObject, TSchema } from "typebox";
 import { Instruction } from "exact-mirror";
+import { Static, StaticDecode, StaticEncode, TIntersect, TObject, TSchema } from "typebox";
 import { OpenAPIV3 } from "openapi-types";
 
 //#region src/types.d.ts

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "elysia",
 	"description": "Ergonomic Framework for Human",
-	"version": "2.0.0-exp.51",
+	"version": "2.0.0-exp.52",
 	"author": {
 		"name": "saltyAom",
 		"url": "https://github.com/SaltyAom",