elysia 2.0.0-beta.20 → 2.0.0-beta.21

package/dist/type/typebox-type-live.d.ts

@@ -1,5 +1,5 @@
 import { TypeboxTypeNamespaces } from "./typebox-type.js";
-import { Codec, Decode, Evaluate, Intersect, Module, Null, Ref, Refine, Undefined, Unsafe } from "typebox/type";
+import { Codec, Composite, Decode, Evaluate, Interface, Intersect, Mapped, Module, Null, Omit, Partial, Pick, ReadonlyObject, Ref, Refine, Required, Undefined, Unsafe } from "typebox/type";
 
 //#region src/type/typebox-type-live.d.ts
 declare function injectTypeboxType(typebox?: TypeboxTypeNamespaces): void;
@@ -8,4 +8,4 @@ declare function markTypeUsed(): void;
 declare const isTypeUsed: () => boolean;
 declare const isTypeNamespaceLoaded: () => boolean;
 //#endregion
-export { Codec, Decode, Evaluate, Intersect, Module, Null, Ref, Refine, type TypeboxTypeNamespaces, Undefined, Unsafe, injectTypeboxType, isTypeNamespaceLoaded, isTypeUsed, loadTypeNamespace, markTypeUsed };
+export { Codec, Composite, Decode, Evaluate, Interface, Intersect, Mapped, Module, Null, Omit, Partial, Pick, ReadonlyObject, Ref, Refine, Required, type TypeboxTypeNamespaces, Undefined, Unsafe, injectTypeboxType, isTypeNamespaceLoaded, isTypeUsed, loadTypeNamespace, markTypeUsed };

package/dist/type/typebox-type-live.js

@@ -21,13 +21,21 @@ const isTypeNamespaceLoaded = () => true;
 
 //#endregion
 exports.Codec = typebox_type.Codec;
+exports.Composite = typebox_type.Composite;
 exports.Decode = typebox_type.Decode;
 exports.Evaluate = typebox_type.Evaluate;
+exports.Interface = typebox_type.Interface;
 exports.Intersect = typebox_type.Intersect;
+exports.Mapped = typebox_type.Mapped;
 exports.Module = typebox_type.Module;
 exports.Null = typebox_type.Null;
+exports.Omit = typebox_type.Omit;
+exports.Partial = typebox_type.Partial;
+exports.Pick = typebox_type.Pick;
+exports.ReadonlyObject = typebox_type.ReadonlyObject;
 exports.Ref = typebox_type.Ref;
 exports.Refine = typebox_type.Refine;
+exports.Required = typebox_type.Required;
 exports.Undefined = typebox_type.Undefined;
 exports.Unsafe = typebox_type.Unsafe;
 exports.injectTypeboxType = injectTypeboxType;

package/dist/type/typebox-type-live.mjs

@@ -1,5 +1,5 @@
 import * as type from "typebox/type";
-import { Codec, Decode, Evaluate, Intersect, Module, Null, Ref, Refine, Undefined, Unsafe } from "typebox/type";
+import { Codec, Composite, Decode, Evaluate, Interface, Intersect, Mapped, Module, Null, Omit, Partial, Pick, ReadonlyObject, Ref, Refine, Required, Undefined, Unsafe } from "typebox/type";
 import * as system from "./typebox-system-lite.mjs";
 
 //#region src/type/typebox-type-live.ts
@@ -17,4 +17,4 @@ const isTypeUsed = () => true;
 const isTypeNamespaceLoaded = () => true;
 
 //#endregion
-export { Codec, Decode, Evaluate, Intersect, Module, Null, Ref, Refine, Undefined, Unsafe, injectTypeboxType, isTypeNamespaceLoaded, isTypeUsed, loadTypeNamespace, markTypeUsed };
+export { Codec, Composite, Decode, Evaluate, Interface, Intersect, Mapped, Module, Null, Omit, Partial, Pick, ReadonlyObject, Ref, Refine, Required, Undefined, Unsafe, injectTypeboxType, isTypeNamespaceLoaded, isTypeUsed, loadTypeNamespace, markTypeUsed };

package/dist/type/typebox-type.d.ts

@@ -1,5 +1,5 @@
 import * as _$typebox_type0 from "typebox/type";
-import { Codec as Codec$1, Decode as Decode$1, Evaluate as Evaluate$1, Intersect as Intersect$1, Module as Module$1, Null as Null$1, Ref as Ref$1, Refine as Refine$1, Undefined as Undefined$1, Unsafe as Unsafe$1 } from "typebox/type";
+import { Codec as Codec$1, Composite as Composite$1, Decode as Decode$1, Evaluate as Evaluate$1, Interface as Interface$1, Intersect as Intersect$1, Mapped as Mapped$1, Module as Module$1, Null as Null$1, Omit as Omit$1, Partial as Partial$1, Pick as Pick$1, ReadonlyObject as ReadonlyObject$1, Ref as Ref$1, Refine as Refine$1, Required as Required$1, Undefined as Undefined$1, Unsafe as Unsafe$1 } from "typebox/type";
 import * as _$typebox_system0 from "typebox/system";
 
 //#region src/type/typebox-type.d.ts
@@ -12,15 +12,23 @@ declare const markTypeUsed: () => void;
 declare const isTypeUsed: () => boolean;
 declare const isTypeNamespaceLoaded: () => boolean;
 declare let Codec: typeof Codec$1;
+declare let Composite: typeof Composite$1;
 declare let Decode: typeof Decode$1;
 declare let Evaluate: typeof Evaluate$1;
+declare let Interface: typeof Interface$1;
 declare let Intersect: typeof Intersect$1;
+declare let Mapped: typeof Mapped$1;
 declare let Module: typeof Module$1;
 declare let Null: typeof Null$1;
+declare let Omit: typeof Omit$1;
+declare let Partial: typeof Partial$1;
+declare let Pick: typeof Pick$1;
+declare let ReadonlyObject: typeof ReadonlyObject$1;
 declare let Ref: typeof Ref$1;
 declare let Refine: typeof Refine$1;
+declare let Required: typeof Required$1;
 declare let Undefined: typeof Undefined$1;
 declare let Unsafe: typeof Unsafe$1;
 declare function injectTypeboxType(typebox: TypeboxTypeNamespaces): void;
 //#endregion
-export { Codec, Decode, Evaluate, Intersect, Module, Null, Ref, Refine, TypeboxTypeNamespaces, Undefined, Unsafe, injectTypeboxType, isTypeNamespaceLoaded, isTypeUsed, loadTypeNamespace, markTypeUsed };
+export { Codec, Composite, Decode, Evaluate, Interface, Intersect, Mapped, Module, Null, Omit, Partial, Pick, ReadonlyObject, Ref, Refine, Required, TypeboxTypeNamespaces, Undefined, Unsafe, injectTypeboxType, isTypeNamespaceLoaded, isTypeUsed, loadTypeNamespace, markTypeUsed };

package/dist/type/typebox-type.js

@@ -42,26 +42,42 @@ function stub(get) {
 	};
 }
 let Codec = stub(() => Codec);
+let Composite = stub(() => Composite);
 let Decode = stub(() => Decode);
 let Evaluate = stub(() => Evaluate);
+let Interface = stub(() => Interface);
 let Intersect = stub(() => Intersect);
+let Mapped = stub(() => Mapped);
 let Module = stub(() => Module);
 let Null = stub(() => Null);
+let Omit = stub(() => Omit);
+let Partial = stub(() => Partial);
+let Pick = stub(() => Pick);
+let ReadonlyObject = stub(() => ReadonlyObject);
 let Ref = stub(() => Ref);
 let Refine = stub(() => Refine);
+let Required = stub(() => Required);
 let Undefined = stub(() => Undefined);
 let Unsafe = stub(() => Unsafe);
 function injectTypeboxType(typebox) {
 	const first = namespaces === void 0;
 	namespaces = typebox;
 	Codec = typebox.type.Codec;
+	Composite = typebox.type.Composite;
 	Decode = typebox.type.Decode;
 	Evaluate = typebox.type.Evaluate;
+	Interface = typebox.type.Interface;
 	Intersect = typebox.type.Intersect;
+	Mapped = typebox.type.Mapped;
 	Module = typebox.type.Module;
 	Null = typebox.type.Null;
+	Omit = typebox.type.Omit;
+	Partial = typebox.type.Partial;
+	Pick = typebox.type.Pick;
+	ReadonlyObject = typebox.type.ReadonlyObject;
 	Ref = typebox.type.Ref;
 	Refine = typebox.type.Refine;
+	Required = typebox.type.Required;
 	Undefined = typebox.type.Undefined;
 	Unsafe = typebox.type.Unsafe;
 	if (first) typebox.system.Settings.Set({ unionPrioritySort: false });
@@ -74,6 +90,12 @@ Object.defineProperty(exports, 'Codec', {
     return Codec;
   }
 });
+Object.defineProperty(exports, 'Composite', {
+  enumerable: true,
+  get: function () {
+    return Composite;
+  }
+});
 Object.defineProperty(exports, 'Decode', {
   enumerable: true,
   get: function () {
@@ -86,12 +108,24 @@ Object.defineProperty(exports, 'Evaluate', {
     return Evaluate;
   }
 });
+Object.defineProperty(exports, 'Interface', {
+  enumerable: true,
+  get: function () {
+    return Interface;
+  }
+});
 Object.defineProperty(exports, 'Intersect', {
   enumerable: true,
   get: function () {
     return Intersect;
   }
 });
+Object.defineProperty(exports, 'Mapped', {
+  enumerable: true,
+  get: function () {
+    return Mapped;
+  }
+});
 Object.defineProperty(exports, 'Module', {
   enumerable: true,
   get: function () {
@@ -104,6 +138,30 @@ Object.defineProperty(exports, 'Null', {
     return Null;
   }
 });
+Object.defineProperty(exports, 'Omit', {
+  enumerable: true,
+  get: function () {
+    return Omit;
+  }
+});
+Object.defineProperty(exports, 'Partial', {
+  enumerable: true,
+  get: function () {
+    return Partial;
+  }
+});
+Object.defineProperty(exports, 'Pick', {
+  enumerable: true,
+  get: function () {
+    return Pick;
+  }
+});
+Object.defineProperty(exports, 'ReadonlyObject', {
+  enumerable: true,
+  get: function () {
+    return ReadonlyObject;
+  }
+});
 Object.defineProperty(exports, 'Ref', {
   enumerable: true,
   get: function () {
@@ -116,6 +174,12 @@ Object.defineProperty(exports, 'Refine', {
     return Refine;
   }
 });
+Object.defineProperty(exports, 'Required', {
+  enumerable: true,
+  get: function () {
+    return Required;
+  }
+});
 Object.defineProperty(exports, 'Undefined', {
   enumerable: true,
   get: function () {

package/dist/type/typebox-type.mjs

@@ -41,30 +41,46 @@ function stub(get) {
 	};
 }
 let Codec = stub(() => Codec);
+let Composite = stub(() => Composite);
 let Decode = stub(() => Decode);
 let Evaluate = stub(() => Evaluate);
+let Interface = stub(() => Interface);
 let Intersect = stub(() => Intersect);
+let Mapped = stub(() => Mapped);
 let Module = stub(() => Module);
 let Null = stub(() => Null);
+let Omit = stub(() => Omit);
+let Partial = stub(() => Partial);
+let Pick = stub(() => Pick);
+let ReadonlyObject = stub(() => ReadonlyObject);
 let Ref = stub(() => Ref);
 let Refine = stub(() => Refine);
+let Required = stub(() => Required);
 let Undefined = stub(() => Undefined);
 let Unsafe = stub(() => Unsafe);
 function injectTypeboxType(typebox) {
 	const first = namespaces === void 0;
 	namespaces = typebox;
 	Codec = typebox.type.Codec;
+	Composite = typebox.type.Composite;
 	Decode = typebox.type.Decode;
 	Evaluate = typebox.type.Evaluate;
+	Interface = typebox.type.Interface;
 	Intersect = typebox.type.Intersect;
+	Mapped = typebox.type.Mapped;
 	Module = typebox.type.Module;
 	Null = typebox.type.Null;
+	Omit = typebox.type.Omit;
+	Partial = typebox.type.Partial;
+	Pick = typebox.type.Pick;
+	ReadonlyObject = typebox.type.ReadonlyObject;
 	Ref = typebox.type.Ref;
 	Refine = typebox.type.Refine;
+	Required = typebox.type.Required;
 	Undefined = typebox.type.Undefined;
 	Unsafe = typebox.type.Unsafe;
 	if (first) typebox.system.Settings.Set({ unionPrioritySort: false });
 }
 
 //#endregion
-export { Codec, Decode, Evaluate, Intersect, Module, Null, Ref, Refine, Undefined, Unsafe, injectTypeboxType, isTypeNamespaceLoaded, isTypeUsed, loadTypeNamespace, markTypeUsed };
+export { Codec, Composite, Decode, Evaluate, Interface, Intersect, Mapped, Module, Null, Omit, Partial, Pick, ReadonlyObject, Ref, Refine, Required, Undefined, Unsafe, injectTypeboxType, isTypeNamespaceLoaded, isTypeUsed, loadTypeNamespace, markTypeUsed };

package/dist/types.d.ts

@@ -836,6 +836,7 @@ type ObjectMacroDefs<N, AmbientSchema extends RouteSchema, ScopedSchemas extends
   derive: Singleton['derive'] & MacroRefResolve<MacroFn, K extends keyof Refs ? Refs[K] : {}, Definitions['typebox']>;
 }, Definitions['error']>> } & { [K in keyof N]: N[K] extends ((...a: any[]) => any) ? unknown : string extends keyof N[K] ? unknown : { [P in Exclude<keyof N[K], MacroPropertyKey | InputSchemaKey | keyof MacroFn | keyof N>]: `Unknown macro property '${P & string}'` } } & N;
 type CreateEden<Path extends string, Property extends Record<string, unknown> = {}> = Path extends `/${infer Rest}` ? _CreateEden<Rest, Property> : Path extends '' | '/' ? Property : _CreateEden<Path, Property>;
+type CreateRouteEden<BasePath extends string, Path extends string, Property extends Record<string, unknown>> = string extends Path ? {} : CreateEden<JoinPath<BasePath, Path>, Property>;
 type _CreateEden<Path extends string, Property extends Record<string, unknown> = {}> = Path extends `${infer Start}/${infer Rest}` ? { [x in Start]: _CreateEden<Rest, Property> } : Path extends '' ? Property : { [x in Path]: Property };
 /**
  * Value an annotation knob resolves to, `never` when it annotates nothing.
@@ -1112,7 +1113,7 @@ type MergeElysiaInstances<Instances extends AnyElysia[] = [], Prefix extends str
   derive: Singleton['derive'];
 }, Definitions, Metadata, Routes, Ephemeral, Volatile>;
 type WrapFn<Callback extends (...params: any) => MaybePromise<Response> = (request: Request, ...rest: any[]) => MaybePromise<Response>> = (fetch: (request: Request, ...rest: any[]) => MaybePromise<Response>) => Callback;
-type AddRoute<BasePath extends string, Scope extends EventScope, Singleton extends SingletonBase, Definitions extends DefinitionBase, Metadata extends MetadataBase, Routes extends RouteBase, Ephemeral extends EphemeralType, Volatile extends EphemeralType, Method extends string, Path extends string, Schema extends RouteSchema, MacroContext extends RouteSchema, Handle> = Elysia<BasePath, Scope, Singleton, Definitions, Metadata, Routes & CreateEden<JoinPath<BasePath, Path>, { [method in Method]: WithHandledErrors<CreateEdenResponse<Path, Schema, MacroContext, ComposeElysiaResponse<Schema & MacroContext & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], Handle, UnionResponseStatus<Metadata['response'], UnionResponseStatus<Ephemeral['response'], UnionResponseStatus<Volatile['response'], MacroContext['return'] & {}>>>, [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], Path>, UnhandledReturnedErrorOf<Handle, [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']]>>, Handle, [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']]> }>, Ephemeral, Volatile>;
+type AddRoute<BasePath extends string, Scope extends EventScope, Singleton extends SingletonBase, Definitions extends DefinitionBase, Metadata extends MetadataBase, Routes extends RouteBase, Ephemeral extends EphemeralType, Volatile extends EphemeralType, Method extends string, Path extends string, Schema extends RouteSchema, MacroContext extends RouteSchema, Handle> = Elysia<BasePath, Scope, Singleton, Definitions, Metadata, Routes & CreateRouteEden<BasePath, Path, { [method in Method]: WithHandledErrors<CreateEdenResponse<Path, Schema, MacroContext, ComposeElysiaResponse<Schema & MacroContext & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], Handle, UnionResponseStatus<Metadata['response'], UnionResponseStatus<Ephemeral['response'], UnionResponseStatus<Volatile['response'], MacroContext['return'] & {}>>>, [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], Path>, UnhandledReturnedErrorOf<Handle, [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']]>>, Handle, [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']]> }>, Ephemeral, Volatile>;
 type HookContextSchema<Metadata extends MetadataBase, Ephemeral extends EphemeralType, Volatile extends EphemeralType, BasePath extends string> = MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>, BasePath> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'];
 type HookContextSingleton<Singleton extends SingletonBase, Ephemeral extends EphemeralType, Volatile extends EphemeralType> = Singleton & {
   derive: Ephemeral['derive'] & Volatile['derive'];
@@ -1213,7 +1214,7 @@ type ScopedMapDeriveReturn<HookScope extends EventScope, BasePath extends string
   response: UnionResponseStatus<Volatile['response'], ResponseAddition>;
   error: Volatile['error'];
 }>;
-type AddWSRoute<BasePath extends string, Scope extends EventScope, Singleton extends SingletonBase, Definitions extends DefinitionBase, Metadata extends MetadataBase, Routes extends RouteBase, Ephemeral extends EphemeralType, Volatile extends EphemeralType, Path extends string, Schema extends RouteSchema, MacroContext extends RouteSchema, Response> = Elysia<BasePath, Scope, Singleton, Definitions, Metadata, Routes & CreateEden<JoinPath<BasePath, Path>, {
+type AddWSRoute<BasePath extends string, Scope extends EventScope, Singleton extends SingletonBase, Definitions extends DefinitionBase, Metadata extends MetadataBase, Routes extends RouteBase, Ephemeral extends EphemeralType, Volatile extends EphemeralType, Path extends string, Schema extends RouteSchema, MacroContext extends RouteSchema, Response> = Elysia<BasePath, Scope, Singleton, Definitions, Metadata, Routes & CreateRouteEden<BasePath, Path, {
   subscribe: CreateWSEdenResponse<Path, Schema, MacroContext, ComposeElysiaResponse<Schema & MacroContext & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], Response, UnionResponseStatus<Metadata['response'], UnionResponseStatus<Ephemeral['response'], UnionResponseStatus<Volatile['response'], MacroContext['return'] & {}>>>, [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], Path>>;
 }>, Ephemeral, Volatile>;
 type GuardHookSingleton<Singleton extends SingletonBase, Ephemeral extends EphemeralType, Volatile extends EphemeralType, MacroContext> = Singleton & {

package/dist/utils.d.ts

@@ -20,6 +20,8 @@ declare const isNotEmpty: <T extends Object>(obj?: T) => boolean | undefined;
  */
 declare function evictOldestHalf(cache: Map<any, any>): void;
 declare function fnv1a(str: string): number;
+declare const compositionKeys: readonly string[];
+declare function refTargets(roots: unknown[], models?: Record<string, unknown>): (name: string) => Iterable<unknown>;
 /**
  * Maps each lifecycle/derive function to the hash of the named plugin it was
  * first registered on. Used by `.use()` to dedup absorbed hooks: if a fn's
@@ -209,4 +211,4 @@ declare const isSocketQuiet: (socket: {
 }) => boolean;
 declare const isHTMLBundle: (value: unknown) => value is BunHTMLBundlelike;
 //#endregion
-export { ChainNode, CompactBeforeHandleChunk, CompactBeforeHandlePrefix, DeriveEntry, ELYSIA_FORM_PROTOTYPE, assignOwn, authorityEnd, bytes, clearFlattenChainMemo, cloneHook, clonePlainDecorators, clonePlainDeep, coalesceSchemas, compactBeforeHandleConflicts, compactBeforeHandlePrefix, constantTimeEqual, createErrorEventHandler, deriveEntryFn, eventProperties, evictOldestHalf, flattenChain, flattenChainMemo, flattenChainMemoReadonly, fnOrigin, fnv1a, form, formToFormData, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isBlob, isByteStream, isCompactBeforeHandleOnly, isDisposable, isElysiaForm, isEmpty, isHTMLBundle, isLocalScope, isMapDeriveEntry, isNotEmpty, isPlainObject, isRecordNumber, isSingleton, isSocketQuiet, joinPath, macroEpoch, macroOrigin, mapDeriveEntry, markSingletons, mergeArray, mergeDeep, mergeHook, mergeResponse, nullObject, prefix, pushField, redirect, replaceUrlPath, requestId, rootSnapshot, schemaProperties, serializeMacroSeed, sse, sseData, throwLifecycleErrors };
+export { ChainNode, CompactBeforeHandleChunk, CompactBeforeHandlePrefix, DeriveEntry, ELYSIA_FORM_PROTOTYPE, assignOwn, authorityEnd, bytes, clearFlattenChainMemo, cloneHook, clonePlainDecorators, clonePlainDeep, coalesceSchemas, compactBeforeHandleConflicts, compactBeforeHandlePrefix, compositionKeys, constantTimeEqual, createErrorEventHandler, deriveEntryFn, eventProperties, evictOldestHalf, flattenChain, flattenChainMemo, flattenChainMemoReadonly, fnOrigin, fnv1a, form, formToFormData, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isBlob, isByteStream, isCompactBeforeHandleOnly, isDisposable, isElysiaForm, isEmpty, isHTMLBundle, isLocalScope, isMapDeriveEntry, isNotEmpty, isPlainObject, isRecordNumber, isSingleton, isSocketQuiet, joinPath, macroEpoch, macroOrigin, mapDeriveEntry, markSingletons, mergeArray, mergeDeep, mergeHook, mergeResponse, nullObject, prefix, pushField, redirect, refTargets, replaceUrlPath, requestId, rootSnapshot, schemaProperties, serializeMacroSeed, sse, sseData, throwLifecycleErrors };

package/dist/utils.js

@@ -37,6 +37,27 @@ function fnv1a(str) {
 	}
 	return hash >>> 0;
 }
+const compositionKeys = Object.freeze([
+	"allOf",
+	"anyOf",
+	"oneOf",
+	"~cookieFrom"
+]);
+function refTargets(roots, models = {}) {
+	const targets = nullObject();
+	const add = (name, schema) => (targets[name] ??= /* @__PURE__ */ new Set()).add(schema);
+	const seen = /* @__PURE__ */ new Set();
+	const index = (node) => {
+		if (!node || typeof node !== "object" || seen.has(node)) return;
+		seen.add(node);
+		if (typeof node.$id === "string") add(node.$id.slice(node.$id.lastIndexOf("/") + 1), node);
+		for (const key in node) index(node[key]);
+		index(node["~cookieFrom"]);
+	};
+	for (const name in models) add(name, models[name]);
+	roots.concat(Object.values(models)).forEach(index);
+	return (name) => targets[name] ?? [];
+}
 /**
 * Maps each lifecycle/derive function to the hash of the named plugin it was
 * first registered on. Used by `.use()` to dedup absorbed hooks: if a fn's
@@ -713,6 +734,7 @@ exports.clonePlainDeep = clonePlainDeep;
 exports.coalesceSchemas = coalesceSchemas;
 exports.compactBeforeHandleConflicts = compactBeforeHandleConflicts;
 exports.compactBeforeHandlePrefix = compactBeforeHandlePrefix;
+exports.compositionKeys = compositionKeys;
 exports.constantTimeEqual = constantTimeEqual;
 exports.createErrorEventHandler = createErrorEventHandler;
 exports.deriveEntryFn = deriveEntryFn;
@@ -756,6 +778,7 @@ exports.nullObject = nullObject;
 exports.prefix = prefix;
 exports.pushField = pushField;
 exports.redirect = redirect;
+exports.refTargets = refTargets;
 exports.replaceUrlPath = replaceUrlPath;
 exports.requestId = requestId;
 exports.rootSnapshot = rootSnapshot;

package/dist/utils.mjs

@@ -36,6 +36,27 @@ function fnv1a(str) {
 	}
 	return hash >>> 0;
 }
+const compositionKeys = Object.freeze([
+	"allOf",
+	"anyOf",
+	"oneOf",
+	"~cookieFrom"
+]);
+function refTargets(roots, models = {}) {
+	const targets = nullObject();
+	const add = (name, schema) => (targets[name] ??= /* @__PURE__ */ new Set()).add(schema);
+	const seen = /* @__PURE__ */ new Set();
+	const index = (node) => {
+		if (!node || typeof node !== "object" || seen.has(node)) return;
+		seen.add(node);
+		if (typeof node.$id === "string") add(node.$id.slice(node.$id.lastIndexOf("/") + 1), node);
+		for (const key in node) index(node[key]);
+		index(node["~cookieFrom"]);
+	};
+	for (const name in models) add(name, models[name]);
+	roots.concat(Object.values(models)).forEach(index);
+	return (name) => targets[name] ?? [];
+}
 /**
 * Maps each lifecycle/derive function to the hash of the named plugin it was
 * first registered on. Used by `.use()` to dedup absorbed hooks: if a fn's
@@ -701,4 +722,4 @@ const isSocketQuiet = (socket) => socket.readyState === 3 && !socket.data.inflig
 const isHTMLBundle = (value) => Object.prototype.toString.call(value) === "[object HTMLBundle]" || typeof value?.index === "string" && Array.isArray(value.files);
 
 //#endregion
-export { ELYSIA_FORM_PROTOTYPE, assignOwn, authorityEnd, bytes, clearFlattenChainMemo, cloneHook, clonePlainDecorators, clonePlainDeep, coalesceSchemas, compactBeforeHandleConflicts, compactBeforeHandlePrefix, constantTimeEqual, createErrorEventHandler, deriveEntryFn, eventProperties, evictOldestHalf, flattenChain, flattenChainMemo, flattenChainMemoReadonly, fnOrigin, fnv1a, form, formToFormData, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isBlob, isByteStream, isCompactBeforeHandleOnly, isDisposable, isElysiaForm, isEmpty, isHTMLBundle, isLocalScope, isMapDeriveEntry, isNotEmpty, isPlainObject, isRecordNumber, isSingleton, isSocketQuiet, joinPath, macroEpoch, macroOrigin, mapDeriveEntry, markSingletons, mergeArray, mergeDeep, mergeHook, mergeResponse, nullObject, prefix, pushField, redirect, replaceUrlPath, requestId, rootSnapshot, schemaProperties, serializeMacroSeed, sse, sseData, throwLifecycleErrors };
+export { ELYSIA_FORM_PROTOTYPE, assignOwn, authorityEnd, bytes, clearFlattenChainMemo, cloneHook, clonePlainDecorators, clonePlainDeep, coalesceSchemas, compactBeforeHandleConflicts, compactBeforeHandlePrefix, compositionKeys, constantTimeEqual, createErrorEventHandler, deriveEntryFn, eventProperties, evictOldestHalf, flattenChain, flattenChainMemo, flattenChainMemoReadonly, fnOrigin, fnv1a, form, formToFormData, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isBlob, isByteStream, isCompactBeforeHandleOnly, isDisposable, isElysiaForm, isEmpty, isHTMLBundle, isLocalScope, isMapDeriveEntry, isNotEmpty, isPlainObject, isRecordNumber, isSingleton, isSocketQuiet, joinPath, macroEpoch, macroOrigin, mapDeriveEntry, markSingletons, mergeArray, mergeDeep, mergeHook, mergeResponse, nullObject, prefix, pushField, redirect, refTargets, replaceUrlPath, requestId, rootSnapshot, schemaProperties, serializeMacroSeed, sse, sseData, throwLifecycleErrors };

package/dist/ws/route.js

@@ -6,9 +6,11 @@ const require_error = require('../error.js');
 const require_cookie_crypto = require('../cookie/crypto.js');
 const require_adapter_web_standard_handler = require('../adapter/web-standard/handler.js');
 const require_parse_query = require('../parse-query.js');
+const require_compile_aot = require('../compile/aot.js');
 const require_generation = require('../generation.js');
 const require_cookie_config = require('../cookie/config.js');
 const require_cookie_utils = require('../cookie/utils.js');
+const require_handler_utils = require('../handler/utils.js');
 const require_handler_error = require('../handler/error.js');
 const require_compile_handler_utils = require('../compile/handler/utils.js');
 const require_sucrose = require('../sucrose.js');
@@ -177,7 +179,21 @@ function buildWSRoute(route, app) {
 	const inheritedChain = route[6];
 	const composed = require_compile_handler_index.composeRouteHook(instance, route[4], appHookChain, inheritedChain, app, route[7]) ?? hook;
 	let validators;
-	const frozenEager = require_type_bridge.isBridgeLive() ? void 0 : require_compile_handler_frozen_validator.buildFrozenRouteValidator(composed, app, "WS", route[1]);
+	const programId = require_generation.frozenRootOf(app)["~programId"];
+	const captured = require_compile_aot.Compiled.getHandler(programId, "WS", route[1]);
+	let live = false;
+	if (require_compile_aot.Capture.isCapturing()) require_compile_aot.Capture.handler({
+		method: "WS",
+		path: route[1],
+		alias: "",
+		code: "",
+		k: require_compile_handler_index.routeShape(composed, void 0, app)
+	});
+	else if (require_compile_aot.Compiled.hasProgram(programId)) {
+		const shape = require_compile_handler_index.routeShape(composed, void 0, app);
+		live = shape === void 0 || captured?.k !== shape;
+	}
+	const frozenEager = require_type_bridge.isBridgeLive() || live ? void 0 : require_compile_handler_frozen_validator.buildFrozenRouteValidator(composed, app, "WS", route[1]);
 	if (frozenEager) validators = frozenEager;
 	else try {
 		validators = new require_validator_route.RouteValidator(composed, {
@@ -186,7 +202,7 @@ function buildWSRoute(route, app) {
 			normalize: require_generation.frozenRootOf(app)["~config"]?.normalize,
 			sanitize: require_generation.frozenRootOf(app)["~config"]?.sanitize,
 			schemas: composed.schemas,
-			aot: {
+			aot: live ? void 0 : {
 				method: "WS",
 				path: route[1]
 			},
@@ -194,10 +210,12 @@ function buildWSRoute(route, app) {
 		});
 	} catch (error) {
 		if (!require_compile_handler_frozen_validator.isBridgeNotInitialized(error)) throw error;
+		if (live) throw new Error(require_compile_aot.aotDrift("WS", route[1]), { cause: error });
 		const frozen = require_compile_handler_frozen_validator.buildFrozenRouteValidator(composed, app, "WS", route[1]);
 		if (!frozen) throw error;
 		validators = frozen;
 	}
+	if (live && captured) require_compile_aot.warnAotDrift("WS", route[1]);
 	const responseValidator = validators.response;
 	const defaultResponseValidator = responseValidator ? responseValidator[200] ?? responseValidator[Object.keys(responseValidator)[0]] : void 0;
 	const cookieIsOptional = !!composed.cookie?.["~optional"];
@@ -233,9 +251,14 @@ function buildWSRoute(route, app) {
 		mapResponse: mapResponses,
 		afterResponse: afterResponses
 	});
-	const cookieConfig = validators.cookie || inference.cookie ? require_cookie_config.compileCookieConfig(composed.cookie, require_generation.frozenRootOf(app)["~config"]?.cookie) : void 0;
+	const cookieConfig = validators.cookie || inference.cookie ? require_cookie_config.compileCookieConfig(composed.cookie, require_generation.frozenRootOf(app)["~config"]?.cookie, require_generation.frozenRootOf(app)["~ext"]?.models, composed.schemas) : void 0;
+	const signCookies = cookieConfig?.hasSign ? (set) => require_cookie_utils.signCookieValues(set.cookie, cookieConfig) : void 0;
 	const parseMessage = require_ws_parser.createMessageParser(parseHooks);
-	const handleUpgradeError = require_handler_error.createErrorHandler(errorHandlers.length ? errorHandlers : void 0, ((response, set, context) => require_adapter_web_standard_handler.mapResponse(response, set, context?.request)), require_generation.frozenRootOf(app)["~config"]?.allowUnsafeValidationDetails);
+	const handleUpgradeError = require_handler_error.createErrorHandler(errorHandlers.length ? errorHandlers : void 0, ((response, set, context) => {
+		const map = () => require_adapter_web_standard_handler.mapResponse(response, set, context?.request);
+		const pending = signCookies?.(set);
+		return pending ? pending.then(map) : map();
+	}), require_generation.frozenRootOf(app)["~config"]?.allowUnsafeValidationDetails);
 	async function handleError(ws, error) {
 		const errCtx = Object.create(ws);
 		errCtx.error = error;
@@ -422,6 +445,7 @@ function buildWSRoute(route, app) {
 					else require_utils.assignOwn(context, r);
 				} else if (r !== void 0) {
 					if (r instanceof Response) return r;
+					if (signCookies) await signCookies(context.set);
 					return require_adapter_web_standard_handler.mapResponse(r, context.set, context.request);
 				}
 			}
@@ -454,7 +478,11 @@ function buildWSRoute(route, app) {
 				}
 			})) return new Response("Expected a websocket connection", { status: 400 });
 		} catch (error) {
-			return handleUpgradeError(context, error);
+			try {
+				return await handleUpgradeError(context, error);
+			} catch (thrown) {
+				return require_handler_utils.finalizeRouteError(app, context, thrown, signCookies);
+			}
 		}
 	};
 	const options = require_utils.nullObject();

package/dist/ws/route.mjs

@@ -5,16 +5,18 @@ import { ElysiaError, ElysiaStatus, ValidationError, elysiaErrorProblem, interna
 import { hasSyncHmac } from "../cookie/crypto.mjs";
 import { mapResponse } from "../adapter/web-standard/handler.mjs";
 import { parseQueryFromURL } from "../parse-query.mjs";
+import { Capture, Compiled, aotDrift, warnAotDrift } from "../compile/aot.mjs";
 import { frozenRootOf } from "../generation.mjs";
 import { compileCookieConfig } from "../cookie/config.mjs";
-import { buildCookieJar, parseCookieRaw, parseCookieRawDeferred, parseCookieRawLazy } from "../cookie/utils.mjs";
+import { buildCookieJar, parseCookieRaw, parseCookieRawDeferred, parseCookieRawLazy, signCookieValues } from "../cookie/utils.mjs";
+import { finalizeRouteError } from "../handler/utils.mjs";
 import { adoptErrorType, claimsProblemType, createErrorHandler, readAnnotation, resolveStatus, statusFallbackBody } from "../handler/error.mjs";
 import { deriveModes, getQueryParseChannels, replaceDeriveContext } from "../compile/handler/utils.mjs";
 import { sucrose } from "../sucrose.mjs";
 import { StandardValidator } from "../validator/index.mjs";
 import { RouteValidator } from "../validator/route.mjs";
 import { buildFrozenRouteValidator, isBridgeNotInitialized } from "../compile/handler/frozen-validator.mjs";
-import { composeRouteHook, localMacroRoot, resolveWSLocalHook } from "../compile/handler/index.mjs";
+import { composeRouteHook, localMacroRoot, resolveWSLocalHook, routeShape } from "../compile/handler/index.mjs";
 import { ElysiaWS, isGeneratorObject, trackWSSettling } from "./context.mjs";
 import { createMessageParser } from "./parser.mjs";
 
@@ -176,7 +178,21 @@ function buildWSRoute(route, app) {
 	const inheritedChain = route[6];
 	const composed = composeRouteHook(instance, route[4], appHookChain, inheritedChain, app, route[7]) ?? hook;
 	let validators;
-	const frozenEager = isBridgeLive() ? void 0 : buildFrozenRouteValidator(composed, app, "WS", route[1]);
+	const programId = frozenRootOf(app)["~programId"];
+	const captured = Compiled.getHandler(programId, "WS", route[1]);
+	let live = false;
+	if (Capture.isCapturing()) Capture.handler({
+		method: "WS",
+		path: route[1],
+		alias: "",
+		code: "",
+		k: routeShape(composed, void 0, app)
+	});
+	else if (Compiled.hasProgram(programId)) {
+		const shape = routeShape(composed, void 0, app);
+		live = shape === void 0 || captured?.k !== shape;
+	}
+	const frozenEager = isBridgeLive() || live ? void 0 : buildFrozenRouteValidator(composed, app, "WS", route[1]);
 	if (frozenEager) validators = frozenEager;
 	else try {
 		validators = new RouteValidator(composed, {
@@ -185,7 +201,7 @@ function buildWSRoute(route, app) {
 			normalize: frozenRootOf(app)["~config"]?.normalize,
 			sanitize: frozenRootOf(app)["~config"]?.sanitize,
 			schemas: composed.schemas,
-			aot: {
+			aot: live ? void 0 : {
 				method: "WS",
 				path: route[1]
 			},
@@ -193,10 +209,12 @@ function buildWSRoute(route, app) {
 		});
 	} catch (error) {
 		if (!isBridgeNotInitialized(error)) throw error;
+		if (live) throw new Error(aotDrift("WS", route[1]), { cause: error });
 		const frozen = buildFrozenRouteValidator(composed, app, "WS", route[1]);
 		if (!frozen) throw error;
 		validators = frozen;
 	}
+	if (live && captured) warnAotDrift("WS", route[1]);
 	const responseValidator = validators.response;
 	const defaultResponseValidator = responseValidator ? responseValidator[200] ?? responseValidator[Object.keys(responseValidator)[0]] : void 0;
 	const cookieIsOptional = !!composed.cookie?.["~optional"];
@@ -232,9 +250,14 @@ function buildWSRoute(route, app) {
 		mapResponse: mapResponses,
 		afterResponse: afterResponses
 	});
-	const cookieConfig = validators.cookie || inference.cookie ? compileCookieConfig(composed.cookie, frozenRootOf(app)["~config"]?.cookie) : void 0;
+	const cookieConfig = validators.cookie || inference.cookie ? compileCookieConfig(composed.cookie, frozenRootOf(app)["~config"]?.cookie, frozenRootOf(app)["~ext"]?.models, composed.schemas) : void 0;
+	const signCookies = cookieConfig?.hasSign ? (set) => signCookieValues(set.cookie, cookieConfig) : void 0;
 	const parseMessage = createMessageParser(parseHooks);
-	const handleUpgradeError = createErrorHandler(errorHandlers.length ? errorHandlers : void 0, ((response, set, context) => mapResponse(response, set, context?.request)), frozenRootOf(app)["~config"]?.allowUnsafeValidationDetails);
+	const handleUpgradeError = createErrorHandler(errorHandlers.length ? errorHandlers : void 0, ((response, set, context) => {
+		const map = () => mapResponse(response, set, context?.request);
+		const pending = signCookies?.(set);
+		return pending ? pending.then(map) : map();
+	}), frozenRootOf(app)["~config"]?.allowUnsafeValidationDetails);
 	async function handleError(ws, error) {
 		const errCtx = Object.create(ws);
 		errCtx.error = error;
@@ -421,6 +444,7 @@ function buildWSRoute(route, app) {
 					else assignOwn(context, r);
 				} else if (r !== void 0) {
 					if (r instanceof Response) return r;
+					if (signCookies) await signCookies(context.set);
 					return mapResponse(r, context.set, context.request);
 				}
 			}
@@ -453,7 +477,11 @@ function buildWSRoute(route, app) {
 				}
 			})) return new Response("Expected a websocket connection", { status: 400 });
 		} catch (error) {
-			return handleUpgradeError(context, error);
+			try {
+				return await handleUpgradeError(context, error);
+			} catch (thrown) {
+				return finalizeRouteError(app, context, thrown, signCookies);
+			}
 		}
 	};
 	const options = nullObject();

package/package.json

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