elysia 0.7.21 → 0.7.23

package/dist/cjs/compose.js

@@ -21,8 +21,10 @@ const createReport = ({ hasTrace, hasTraceSet = false, addFn, condition = {} })
                     ? event
                     : event.slice(0, dotIndex))])
                 return () => {
-                    if (hasTraceSet && event === 'afterHandle')
-                        addFn('\nawait traceDone\n');
+                    if (hasTraceSet && event === 'afterHandle') {
+                        addFn(`reporter.emit('event',{id,event:'exit',type:'begin',time:0})`);
+                        addFn(`\nawait traceDone\n`);
+                    }
                 };
             if (isGroup)
                 name ||= event;
@@ -52,8 +54,10 @@ const createReport = ({ hasTrace, hasTraceSet = false, addFn, condition = {} })
 							time: performance.now()
 						})`.replace(/(\t| |\n)/g, '') +
                     '\n');
-                if (hasTraceSet && event === 'afterHandle')
+                if (hasTraceSet && event === 'afterHandle') {
+                    addFn(`\nreporter.emit('event',{id,event:'exit',type:'begin',time:0})\n`);
                     addFn('\nawait traceDone\n');
+                }
             };
         };
     }
@@ -458,9 +462,14 @@ const composeHandler = ({ path, method, hooks, validator, handler, handleError,
         }
     });
     fnLiteral += hasErrorHandler ? 'try {\n' : '';
-    if (hasTrace)
-        fnLiteral +=
-            '\nconst traceDone = new Promise(r => { reporter.once(`res${id}`, r) })\n';
+    if (hasTrace) {
+        // fnLiteral += `\nconst traceDone = new Promise(r => r())\n`
+        fnLiteral += `\nconst traceDone = Promise.all([`;
+        for (let i = 0; i < hooks.trace.length; i++) {
+            fnLiteral += `new Promise(r => { reporter.once(\`res\${id}.${i}\`, r) }),`;
+        }
+        fnLiteral += `])\n`;
+    }
     const maybeAsync = hasCookie ||
         hasBody ||
         hasTraceSet ||
@@ -800,8 +809,6 @@ const composeHandler = ({ path, method, hooks, validator, handler, handleError,
                 else {
                     fnLiteral += `if(${name}) {`;
                     endAfterHandle();
-                    if (hasTraceSet)
-                        fnLiteral += `${name} = mapEarlyResponse(${name}, c.set)\n`;
                     fnLiteral += `return ${name}}\n`;
                 }
             }
@@ -906,7 +913,6 @@ const composeHandler = ({ path, method, hooks, validator, handler, handleError,
             fnLiteral += `}`;
         }
     }
-    // console.log(fnLiteral)
     fnLiteral = `const { 
 		handler,
 		handleError,

package/dist/cjs/index.d.ts

@@ -980,5 +980,5 @@ export { Cookie, type CookieOptions } from './cookie';
 export { getSchemaValidator, mergeDeep, mergeHook, mergeObjectArray, getResponseSchemaValidator } from './utils';
 export { ParseError, NotFoundError, ValidationError, InternalServerError, InvalidCookieSignature } from './error';
 export type { Context, PreContext } from './context';
-export type { ElysiaConfig, DecoratorBase, DefinitionBase, RouteBase, Handler, ComposedHandler, InputSchema, LocalHook, MergeSchema, RouteSchema, UnwrapRoute, InternalRoute, HTTPMethod, SchemaValidator, VoidHandler, PreHandler, BodyHandler, OptionalHandler, ErrorHandler, AfterHandler, TraceHandler, TraceStream, LifeCycleEvent, TraceEvent, LifeCycleStore, MaybePromise, ListenCallback, UnwrapSchema } from './types';
+export type { ElysiaConfig, DecoratorBase, DefinitionBase, RouteBase, Handler, ComposedHandler, InputSchema, LocalHook, MergeSchema, RouteSchema, UnwrapRoute, InternalRoute, HTTPMethod, SchemaValidator, VoidHandler, PreHandler, BodyHandler, OptionalHandler, ErrorHandler, AfterHandler, LifeCycleEvent, TraceEvent, LifeCycleStore, MaybePromise, ListenCallback, UnwrapSchema, TraceHandler, TraceProcess, TraceReporter, TraceStream } from './types';
 export type { Static } from '@sinclair/typebox';

package/dist/cjs/index.js

@@ -556,7 +556,7 @@ class Elysia {
      * ```
      */
     trace(handler) {
-        this.reporter.on('event', (0, trace_1.createTraceListener)(() => this.reporter, handler));
+        this.reporter.on('event', (0, trace_1.createTraceListener)(() => this.reporter, this.event.trace.length, handler));
         this.on('trace', handler);
         return this;
     }

package/dist/cjs/trace.d.ts

@@ -1,2 +1,2 @@
 import type { TraceHandler, TraceReporter, TraceStream } from './types';
-export declare const createTraceListener: (getReporter: () => TraceReporter, handler: TraceHandler<any, any>) => (event: TraceStream) => Promise<void>;
+export declare const createTraceListener: (getReporter: () => TraceReporter, totalListener: number, handler: TraceHandler<any, any>) => (trace: TraceStream) => Promise<void>;

package/dist/cjs/trace.js

@@ -1,217 +1,204 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTraceListener = void 0;
-const createTraceListener = (getReporter, handler) => {
-    return async function trace(event) {
-        const id = event.id;
-        if (event.event === 'request' && event.type === 'begin') {
-            const reporter = getReporter();
-            const createSignal = () => {
-                let resolveHandle;
-                let resolveHandleEnd;
-                let childIteration = -1;
-                const children = [];
-                const endChildren = [];
-                let resolved = false;
-                const handle = new Promise((resolve) => {
-                    resolveHandle = (a) => {
-                        if (resolved)
-                            return;
-                        else
-                            resolved = true;
-                        resolve(a);
-                    };
-                });
-                let resolvedEnd = false;
-                const handleEnd = new Promise((resolve) => {
-                    resolveHandleEnd = (a) => {
-                        if (resolvedEnd)
-                            return;
-                        else
-                            resolvedEnd = true;
-                        if (childIteration === -1)
-                            childIteration = 0;
-                        for (; childIteration < endChildren.length; childIteration++) {
-                            // eslint-disable-next-line prefer-const
-                            let end;
-                            const start = {
-                                name: 'anonymous',
-                                time: performance.now(),
-                                skip: true,
-                                end: new Promise((resolve) => {
-                                    resolve(end);
-                                }),
-                                children: []
-                            };
-                            end = performance.now();
-                            children[childIteration](start);
-                        }
-                        resolve(a);
-                    };
-                });
-                return {
-                    signal: handle,
-                    consumeChild(event) {
-                        switch (event.type) {
-                            case 'begin':
-                                const child = children[++childIteration];
-                                // Child may cause early return
-                                if (child)
-                                    child({
-                                        name: event.name,
-                                        time: event.time,
+const resolver = () => {
+    let resolve;
+    const promise = new Promise((r) => {
+        resolve = r;
+    });
+    return [promise, resolve];
+};
+const createSignal = () => {
+    const [start, resolveStart] = resolver();
+    const [end, resolveEnd] = resolver();
+    const children = [];
+    const resolvers = [];
+    return {
+        signal: start,
+        consume: (trace) => {
+            switch (trace.type) {
+                case 'begin':
+                    if (trace.unit && children.length === 0)
+                        for (let i = 0; i < trace.unit; i++) {
+                            const [start, resolveStart] = resolver();
+                            const [end, resolveEnd] = resolver();
+                            children.push(start);
+                            resolvers.push([
+                                (trace) => {
+                                    resolveStart({
+                                        children: [],
+                                        end,
+                                        name: trace.name ?? '',
                                         skip: false,
-                                        end: new Promise((resolve) => {
-                                            endChildren.push(resolve);
-                                        })
+                                        time: trace.time
                                     });
-                                else {
-                                    this.resolve();
-                                    console.log("SKIP");
+                                },
+                                (time) => {
+                                    resolveEnd(time);
                                 }
-                                break;
-                            case 'end':
-                                endChildren[childIteration]?.(event.time);
-                                break;
+                            ]);
                         }
-                    },
-                    consume(event) {
-                        switch (event.type) {
-                            case 'begin':
-                                const unitsProcess = [];
-                                const units = event.unit ?? 0;
-                                for (let i = 0; i < units; i++) {
-                                    let resolveChild;
-                                    unitsProcess.push(new Promise((resolve) => {
-                                        resolveChild = resolve;
-                                    }));
-                                    children.push(resolveChild);
-                                }
-                                resolveHandle({
-                                    // Begin always have name
-                                    name: event.name,
-                                    time: event.time,
-                                    skip: false,
-                                    end: handleEnd,
-                                    children: unitsProcess
-                                });
-                                break;
-                            case 'end':
-                                resolveHandleEnd(event.time);
-                                break;
-                        }
-                    },
-                    resolve() {
-                        if (resolved && resolvedEnd)
-                            return;
-                        // eslint-disable-next-line prefer-const
-                        let end;
-                        const start = {
-                            name: 'anonymous',
-                            time: performance.now(),
-                            skip: true,
-                            end: new Promise((resolve) => {
-                                resolve(end);
-                            }),
-                            children: []
-                        };
-                        end = performance.now();
-                        resolveHandle(start);
-                        resolveHandleEnd(end);
-                    }
-                };
-            };
-            const request = createSignal();
-            const parse = createSignal();
-            const transform = createSignal();
-            const beforeHandle = createSignal();
-            const handle = createSignal();
-            const afterHandle = createSignal();
-            const error = createSignal();
-            const response = createSignal();
-            request.consume(event);
-            const reducer = (event) => {
-                if (event.id === id)
-                    switch (event.event) {
-                        case 'request':
-                            request.consume(event);
-                            break;
-                        case 'request.unit':
-                            request.consumeChild(event);
-                            break;
-                        case 'parse':
-                            parse.consume(event);
-                            break;
-                        case 'parse.unit':
-                            parse.consumeChild(event);
-                            break;
-                        case 'transform':
-                            transform.consume(event);
-                            break;
-                        case 'transform.unit':
-                            transform.consumeChild(event);
-                            break;
-                        case 'beforeHandle':
-                            beforeHandle.consume(event);
-                            break;
-                        case 'beforeHandle.unit':
-                            beforeHandle.consumeChild(event);
-                            break;
-                        case 'handle':
-                            handle.consume(event);
-                            break;
-                        case 'afterHandle':
-                            afterHandle.consume(event);
-                            break;
-                        case 'afterHandle.unit':
-                            afterHandle.consumeChild(event);
-                            break;
-                        case 'error':
-                            error.consume(event);
-                            break;
-                        case 'error.unit':
-                            error.consumeChild(event);
-                            break;
-                        case 'response':
-                            if (event.type === 'begin') {
-                                request.resolve();
-                                parse.resolve();
-                                transform.resolve();
-                                beforeHandle.resolve();
-                                handle.resolve();
-                                afterHandle.resolve();
-                                error.resolve();
-                            }
-                            else
-                                reporter.off('event', reducer);
-                            response.consume(event);
-                            break;
-                        case 'response.unit':
-                            response.consumeChild(event);
-                            break;
-                    }
-            };
-            reporter.on('event', reducer);
-            await handler({
-                id: event.id,
-                // @ts-ignore
-                context: event.ctx,
-                // @ts-ignore
-                set: event.ctx?.set,
-                // @ts-ignore
-                store: event.ctx?.store,
-                time: event.time,
-                request: request.signal,
-                parse: parse.signal,
-                transform: transform.signal,
-                beforeHandle: beforeHandle.signal,
-                handle: handle.signal,
-                afterHandle: afterHandle.signal,
-                error: error.signal,
-                response: response.signal
+                    resolveStart({
+                        children,
+                        end,
+                        name: trace.name ?? '',
+                        skip: false,
+                        time: trace.time
+                    });
+                    break;
+                case 'end':
+                    resolveEnd(trace.time);
+                    break;
+            }
+        },
+        consumeChild(trace) {
+            switch (trace.type) {
+                case 'begin':
+                    if (!resolvers[0])
+                        return;
+                    const [resolveStart] = resolvers[0];
+                    resolveStart({
+                        children: [],
+                        end,
+                        name: trace.name ?? '',
+                        skip: false,
+                        time: trace.time
+                    });
+                    break;
+                case 'end':
+                    const child = resolvers.shift();
+                    if (!child)
+                        return;
+                    child[1](trace.time);
+            }
+        },
+        resolve() {
+            resolveStart({
+                children: [],
+                end: new Promise((resolve) => resolve(0)),
+                name: '',
+                skip: true,
+                time: 0
             });
-            reporter.emit(`res${id}`, undefined);
+            for (const [resolveStart, resolveEnd] of resolvers) {
+                resolveStart({
+                    children: [],
+                    end: new Promise((resolve) => resolve(0)),
+                    name: '',
+                    skip: true,
+                    time: 0
+                });
+                resolveEnd(0);
+            }
+            resolveEnd(0);
         }
     };
 };
+const createTraceListener = (getReporter, totalListener, handler) => {
+    return async function trace(trace) {
+        if (trace.event !== 'request' || trace.type !== 'begin')
+            return;
+        const id = trace.id;
+        const reporter = getReporter();
+        const request = createSignal();
+        const parse = createSignal();
+        const transform = createSignal();
+        const beforeHandle = createSignal();
+        const handle = createSignal();
+        const afterHandle = createSignal();
+        const error = createSignal();
+        const response = createSignal();
+        request.consume(trace);
+        const reducer = (event) => {
+            if (event.id === id)
+                switch (event.event) {
+                    case 'request':
+                        request.consume(event);
+                        break;
+                    case 'request.unit':
+                        request.consumeChild(event);
+                        break;
+                    case 'parse':
+                        parse.consume(event);
+                        break;
+                    case 'parse.unit':
+                        parse.consumeChild(event);
+                        break;
+                    case 'transform':
+                        transform.consume(event);
+                        break;
+                    case 'transform.unit':
+                        transform.consumeChild(event);
+                        break;
+                    case 'beforeHandle':
+                        beforeHandle.consume(event);
+                        break;
+                    case 'beforeHandle.unit':
+                        beforeHandle.consumeChild(event);
+                        break;
+                    case 'handle':
+                        handle.consume(event);
+                        break;
+                    case 'afterHandle':
+                        afterHandle.consume(event);
+                        break;
+                    case 'afterHandle.unit':
+                        afterHandle.consumeChild(event);
+                        break;
+                    case 'error':
+                        error.consume(event);
+                        break;
+                    case 'error.unit':
+                        error.consumeChild(event);
+                        break;
+                    case 'response':
+                        if (event.type === 'begin') {
+                            request.resolve();
+                            parse.resolve();
+                            transform.resolve();
+                            beforeHandle.resolve();
+                            handle.resolve();
+                            afterHandle.resolve();
+                            error.resolve();
+                        }
+                        else
+                            reporter.off('event', reducer);
+                        response.consume(event);
+                        break;
+                    case 'response.unit':
+                        response.consumeChild(event);
+                        break;
+                    case 'exit':
+                        request.resolve();
+                        parse.resolve();
+                        transform.resolve();
+                        beforeHandle.resolve();
+                        handle.resolve();
+                        afterHandle.resolve();
+                        error.resolve();
+                        break;
+                }
+        };
+        reporter.on('event', reducer);
+        await handler({
+            id,
+            // @ts-ignore
+            context: trace.ctx,
+            // @ts-ignore
+            set: trace.ctx?.set,
+            // @ts-ignore
+            store: trace.ctx?.store,
+            time: trace.time,
+            request: request.signal,
+            parse: parse.signal,
+            transform: transform.signal,
+            beforeHandle: beforeHandle.signal,
+            handle: handle.signal,
+            afterHandle: afterHandle.signal,
+            error: error.signal,
+            response: response.signal
+        });
+        reporter.emit(`res${id}.${totalListener}`, undefined);
+    };
+};
 exports.createTraceListener = createTraceListener;

package/dist/cjs/types.d.ts

@@ -165,7 +165,7 @@ export type VoidHandler<Route extends RouteSchema = {}, Decorators extends Decor
     request: {};
     store: {};
 }> = (context: Prettify<Context<Route, Decorators>>) => MaybePromise<void>;
-export type TraceEvent = 'request' | 'parse' | 'transform' | 'beforeHandle' | 'afterHandle' | 'error' | 'response' extends infer Events extends string ? Events | `${Events}.unit` | 'handle' : never;
+export type TraceEvent = 'request' | 'parse' | 'transform' | 'beforeHandle' | 'afterHandle' | 'error' | 'response' extends infer Events extends string ? Events | `${Events}.unit` | 'handle' | 'exit' : never;
 export type TraceStream = {
     id: number;
     event: TraceEvent;
@@ -175,7 +175,7 @@ export type TraceStream = {
     unit?: number;
 };
 export type TraceReporter = EventEmitter<{
-    [res in `res${number}`]: undefined;
+    [res in `res${number}.${number}`]: undefined;
 } & {
     event(stream: TraceStream): MaybePromise<void>;
 }>;

package/dist/cjs/utils.js

@@ -182,7 +182,11 @@ const mergeLifeCycle = (a, b, checksum) => {
         beforeHandle: (0, exports.mergeObjectArray)(a.beforeHandle, (b?.beforeHandle ?? []).map(injectChecksum)),
         afterHandle: (0, exports.mergeObjectArray)(a.afterHandle, (b?.afterHandle ?? []).map(injectChecksum)),
         onResponse: (0, exports.mergeObjectArray)(a.onResponse, (b?.onResponse ?? []).map(injectChecksum)),
-        trace: (0, exports.mergeObjectArray)(a.trace, ('trace' in b ? b.trace ?? [] : []).map(injectChecksum)),
+        trace: a.trace,
+        // trace: mergeObjectArray(
+        // 	a.trace as any,
+        // 	('trace' in b ? b.trace ?? [] : ([] as any)).map(injectChecksum)
+        // ),
         error: (0, exports.mergeObjectArray)(a.error, (b?.error ?? []).map(injectChecksum)),
         stop: (0, exports.mergeObjectArray)(a.stop, ('stop' in b ? b.stop ?? [] : []).map(injectChecksum))
     };

package/dist/compose.js

@@ -1,6 +1,8 @@
 import{parse as e}from"fast-querystring";import{signCookie as t}from"./utils";import{mapEarlyResponse as r,mapResponse as s,mapCompactResponse as n,isNotEmpty as o}from"./handler";import{NotFoundError as a,ValidationError as i,InternalServerError as c,ERROR_CODE as l}from"./error";import{parseCookie as f}from"./cookie";let u=new Headers().toJSON,d=RegExp(" (\\w+) = context","g"),p={value:0},m=({hasTrace:e,hasTraceSet:t=!1,addFn:r,condition:s={}})=>(r(`
 const reporter = getReporter()
-`),e)?(e,{name:n,attribute:o="",unit:a=0}={})=>{let i=e.indexOf("."),c=-1===i;if("request"!==e&&"response"!==e&&!s[c?e:e.slice(0,i)])return()=>{t&&"afterHandle"===e&&r("\nawait traceDone\n")};c?n||=e:n||="anonymous",r("\n"+`reporter.emit('event', { 
+`),e)?(e,{name:n,attribute:o="",unit:a=0}={})=>{let i=e.indexOf("."),c=-1===i;if("request"!==e&&"response"!==e&&!s[c?e:e.slice(0,i)])return()=>{t&&"afterHandle"===e&&(r("reporter.emit('event',{id,event:'exit',type:'begin',time:0})"),r(`
+await traceDone
+`))};c?n||=e:n||="anonymous",r("\n"+`reporter.emit('event', { 
 					id,
 					event: '${e}',
 					type: 'begin',
@@ -13,7 +15,9 @@ const reporter = getReporter()
 							event: '${e}',
 							type: 'end',
 							time: performance.now()
-						})`.replace(/(\t| |\n)/g,"")+"\n"),t&&"afterHandle"===e&&r("\nawait traceDone\n"))}}:()=>()=>{};export const hasReturn=e=>{let t=e.indexOf(")");return(// Is direct arrow function return eg. () => 1
+						})`.replace(/(\t| |\n)/g,"")+"\n"),t&&"afterHandle"===e&&(r(`
+reporter.emit('event',{id,event:'exit',type:'begin',time:0})
+`),r("\nawait traceDone\n")))}}:()=>()=>{};export const hasReturn=e=>{let t=e.indexOf(")");return(// Is direct arrow function return eg. () => 1
 61===e.charCodeAt(t+2)&&123!==e.charCodeAt(t+5)||e.includes("return"))};let h=(e,{injectResponse:t=""}={})=>({composeValidation:(t,r=`c.${t}`)=>e?`c.set.status = 400; throw new ValidationError(
 '${t}',
 ${t},
@@ -57,7 +61,7 @@ if(t.match(RegExp(`${r}(.${e}|\\["${e}"\\])`)))return!0;let n=-1!==s?r.slice(s+3
  * ```
  */let b=e=>{if(!e)return;// @ts-ignore
 let t=e?.schema;if(t&&"anyOf"in t){let e=!1,r=t.anyOf[0].type;for(let s of t.anyOf)if(s.type!==r){e=!0;break}if(!e)return r}// @ts-ignore
-return e.schema?.type},k=/(?:return|=>) \S*\(/g;export const isAsync=e=>"AsyncFunction"===e.constructor.name||e.toString().match(k);export const composeHandler=({path:d,method:$,hooks:g,validator:k,handler:w,handleError:R,definitions:x,schema:q,onRequest:H,config:E,getReporter:v})=>{let O=E.forceErrorEncapsulation||g.error.length>0||"undefined"==typeof Bun||g.onResponse.length>0||!!g.trace.length,A=g.onResponse.length?`
+return e.schema?.type},k=/(?:return|=>) \S*\(/g;export const isAsync=e=>"AsyncFunction"===e.constructor.name||e.toString().match(k);export const composeHandler=({path:d,method:$,hooks:g,validator:k,handler:w,handleError:x,definitions:R,schema:q,onRequest:H,config:v,getReporter:E})=>{let O=v.forceErrorEncapsulation||g.error.length>0||"undefined"==typeof Bun||g.onResponse.length>0||!!g.trace.length,A=g.onResponse.length?`
 ;(async () => {${g.onResponse.map((e,t)=>`await res${t}(c)`).join(";")}})();
 `:"",C=g.trace.map(e=>e.toString()),F=!1;if(y(w.toString())&&(F=!0),!F){for(let[e,t]of Object.entries(g))if(Array.isArray(t)&&t.length&&["parse","transform","beforeHandle","afterHandle","onResponse"].includes(e)){for(let e of t)if("function"==typeof e&&y(e.toString())){F=!0;break}if(F)break}}let j={parse:C.some(e=>isFnUse("parse",e)),transform:C.some(e=>isFnUse("transform",e)),handle:C.some(e=>isFnUse("handle",e)),beforeHandle:C.some(e=>isFnUse("beforeHandle",e)),afterHandle:C.some(e=>isFnUse("afterHandle",e)),error:O||C.some(e=>isFnUse("error",e))},T=g.trace.length>0,S="",U=k||"GET"!==$&&"HEAD"!==$?[w,...g.transform,...g.beforeHandle,...g.afterHandle].map(e=>e.toString()):[],D=F||"GET"!==$&&"HEAD"!==$&&"none"!==g.type&&(!!k.body||!!g.type||U.some(e=>isFnUse("body",e))),V=F||k.headers||U.some(e=>isFnUse("headers",e)),N=F||k.cookie||U.some(e=>isFnUse("cookie",e)),_=k?.cookie?.schema,I="";if(_?.sign){if(!_.secrets)throw Error(`t.Cookie required secret which is not set in (${$}) ${d}.`);let e=_.secrets?"string"==typeof _.secrets?_.secrets:_.secrets[0]:void 0;if(I+=`const _setCookie = c.set.cookie
 		if(_setCookie) {`,!0===_.sign)// encodeCookie += `if(_setCookie['${name}']?.value) { c.set.cookie['${name}'].value = await signCookie(_setCookie['${name}'].value, '${secret}') }\n`
@@ -87,14 +91,17 @@ let r=_?.[e]??t;return r?"string"==typeof r?`${e}: '${r}',`:r instanceof Date?`$
 c.cookie = await parseCookie(c.set, c.headers.cookie, ${t})
 `:S+=`
 c.cookie = await parseCookie(c.set, c.request.headers.get('cookie'), ${t})
-`}let G=F||k.query||U.some(e=>isFnUse("query",e));G&&(S+=`const url = c.request.url
+`}let P=F||k.query||U.some(e=>isFnUse("query",e));P&&(S+=`const url = c.request.url
 
 		if(c.qi !== -1) {
 			c.query ??= parseQuery(url.substring(c.qi + 1))
 		} else {
 			c.query ??= {}
 		}
-		`);let L=g.trace.map(e=>e.toString()),P=L.some(e=>isFnUse("set",e)||y(e));F||g.trace.some(e=>isFnUse("set",e.toString()));let Q=P||N||U.some(e=>isFnUse("set",e))||H.some(e=>isFnUse("set",e.toString()));T&&(S+="\nconst id = c.$$requestId\n");let K=m({hasTrace:T,hasTraceSet:P,condition:j,addFn:e=>{S+=e}});S+=O?"try {\n":"",T&&(S+="\nconst traceDone = new Promise(r => { reporter.once(`res${id}`, r) })\n");let J=N||D||P||isAsync(w)||g.parse.length>0||g.afterHandle.some(isAsync)||g.beforeHandle.some(isAsync)||g.transform.some(isAsync),z=K("parse",{unit:g.parse.length});if(D){let e=b(k?.body);if(g.type&&!Array.isArray(g.type)){if(g.type)switch(g.type){case"json":case"application/json":S+=`c.body = await c.request.json()
+		`);let G=g.trace.map(e=>e.toString()),L=G.some(e=>isFnUse("set",e)||y(e));F||g.trace.some(e=>isFnUse("set",e.toString()));let Q=L||N||U.some(e=>isFnUse("set",e))||H.some(e=>isFnUse("set",e.toString()));T&&(S+="\nconst id = c.$$requestId\n");let K=m({hasTrace:T,hasTraceSet:L,condition:j,addFn:e=>{S+=e}});if(S+=O?"try {\n":"",T){// fnLiteral += `\nconst traceDone = new Promise(r => r())\n`
+S+=`
+const traceDone = Promise.all([`;for(let e=0;e<g.trace.length;e++)S+=`new Promise(r => { reporter.once(\`res\${id}.${e}\`, r) }),`;S+=`])
+`}let J=N||D||L||isAsync(w)||g.parse.length>0||g.afterHandle.some(isAsync)||g.beforeHandle.some(isAsync)||g.transform.some(isAsync),z=K("parse",{unit:g.parse.length});if(D){let e=b(k?.body);if(g.type&&!Array.isArray(g.type)){if(g.type)switch(g.type){case"json":case"application/json":S+=`c.body = await c.request.json()
 `;break;case"text":case"text/plain":S+=`c.body = await c.request.text()
 `;break;case"urlencoded":case"application/x-www-form-urlencoded":S+=`c.body = parseQuery(await c.request.text())
 `;break;case"arrayBuffer":case"application/octet-stream":S+=`c.body = await c.request.arrayBuffer()
@@ -212,9 +219,8 @@ c.cookie = params.Decode(c.cookie)
 `:S+=isAsync(g.afterHandle[e])?`let ${r} = mapEarlyResponse(await afterHandle[${e}](c), c.set)
 `:`let ${r} = mapEarlyResponse(afterHandle[${e}](c), c.set)
 `,n(),k.response?(S+=`if(${r} !== undefined) {`+W(r)+`${r} = mapEarlyResponse(${r}, c.set)
-`+`if(${r}) {`,t(),P&&(S+=`${r} = mapEarlyResponse(${r}, c.set)
-`),S+=`return ${r} } }`):(S+=`if(${r}) {`,t(),P&&(S+=`${r} = mapEarlyResponse(${r}, c.set)
-`),S+=`return ${r}}
+`+`if(${r}) {`,t(),L&&(S+=`${r} = mapEarlyResponse(${r}, c.set)
+`),S+=`return ${r} } }`):(S+=`if(${r}) {`,t(),S+=`return ${r}}
 `)):(S+=isAsync(g.afterHandle[e])?`await afterHandle[${e}](c)
 `:`afterHandle[${e}](c)
 `,n())}t(),S+=`r = c.response
@@ -246,8 +252,7 @@ let ${t} = handleErrors[${e}](
 if (${t}) {return ${t} }
 `}if(e(),S+=`return handleError(c, error)
 
-`,J||(S+="})()"),S+="}",A||T){S+=" finally { ";let e=K("response",{unit:g.onResponse.length});S+=A,e(),S+="}"}}// console.log(fnLiteral)
-S=`const { 
+`,J||(S+="})()"),S+="}",A||T){S+=" finally { ";let e=K("response",{unit:g.onResponse.length});S+=A,e(),S+="}"}}S=`const { 
 		handler,
 		handleError,
 		hooks: {
@@ -289,9 +294,9 @@ S=`const {
 	${g.onResponse.length?`const ${g.onResponse.map((e,t)=>`res${t} = onResponse[${t}]`).join(",")}`:""}
 
 	return ${J?"async":""} function(c) {
-		${q&&x?"c.schema = schema; c.defs = definitions;":""}
+		${q&&R?"c.schema = schema; c.defs = definitions;":""}
 		${S}
-	}`;let M=Function("hooks",S);return M({handler:w,hooks:g,validator:k,handleError:R,utils:{mapResponse:s,mapCompactResponse:n,mapEarlyResponse:r,parseQuery:e},error:{NotFoundError:a,ValidationError:i,InternalServerError:c},schema:q,definitions:x,ERROR_CODE:l,getReporter:v,requestId:p,parseCookie:f,signCookie:t})};export const composeGeneralHandler=e=>{let t="",s="";// @ts-ignore
+	}`;let M=Function("hooks",S);return M({handler:w,hooks:g,validator:k,handleError:x,utils:{mapResponse:s,mapCompactResponse:n,mapEarlyResponse:r,parseQuery:e},error:{NotFoundError:a,ValidationError:i,InternalServerError:c},schema:q,definitions:R,ERROR_CODE:l,getReporter:E,requestId:p,parseCookie:f,signCookie:t})};export const composeGeneralHandler=e=>{let t="",s="";// @ts-ignore
 for(let r of Object.keys(e.decorators))t+=`,${r}: app.decorators.${r}`;// @ts-ignore
 let{router:n,staticRouter:o}=e,i=e.event.trace.length>0,c=`
 	const route = find(request.method, path) ${n.root.ALL?'?? find("ALL", path)':""}

package/dist/index.d.ts

@@ -980,5 +980,5 @@ export { Cookie, type CookieOptions } from './cookie';
 export { getSchemaValidator, mergeDeep, mergeHook, mergeObjectArray, getResponseSchemaValidator } from './utils';
 export { ParseError, NotFoundError, ValidationError, InternalServerError, InvalidCookieSignature } from './error';
 export type { Context, PreContext } from './context';
-export type { ElysiaConfig, DecoratorBase, DefinitionBase, RouteBase, Handler, ComposedHandler, InputSchema, LocalHook, MergeSchema, RouteSchema, UnwrapRoute, InternalRoute, HTTPMethod, SchemaValidator, VoidHandler, PreHandler, BodyHandler, OptionalHandler, ErrorHandler, AfterHandler, TraceHandler, TraceStream, LifeCycleEvent, TraceEvent, LifeCycleStore, MaybePromise, ListenCallback, UnwrapSchema } from './types';
+export type { ElysiaConfig, DecoratorBase, DefinitionBase, RouteBase, Handler, ComposedHandler, InputSchema, LocalHook, MergeSchema, RouteSchema, UnwrapRoute, InternalRoute, HTTPMethod, SchemaValidator, VoidHandler, PreHandler, BodyHandler, OptionalHandler, ErrorHandler, AfterHandler, LifeCycleEvent, TraceEvent, LifeCycleStore, MaybePromise, ListenCallback, UnwrapSchema, TraceHandler, TraceProcess, TraceReporter, TraceStream } from './types';
 export type { Static } from '@sinclair/typebox';

package/dist/index.js

@@ -139,7 +139,7 @@ ${this.staticRouter.map[v].code}`)}else this.router.add(e,h,y),this.config.stric
 	 *             return JSON.stringify(response)
 	 *     })
 	 * ```
-	 */trace(e){return this.reporter.on("event",r(()=>this.reporter,e)),this.on("trace",e),this}addError(// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	 */trace(e){return this.reporter.on("event",r(()=>this.reporter,this.event.trace.length,e)),this.on("trace",e),this}addError(// eslint-disable-next-line @typescript-eslint/no-unused-vars
 e,// eslint-disable-next-line @typescript-eslint/no-unused-vars
 t){return this.error(e,t)}error(// eslint-disable-next-line @typescript-eslint/no-unused-vars
 e,// eslint-disable-next-line @typescript-eslint/no-unused-vars

package/dist/trace.d.ts

@@ -1,2 +1,2 @@
 import type { TraceHandler, TraceReporter, TraceStream } from './types';
-export declare const createTraceListener: (getReporter: () => TraceReporter, handler: TraceHandler<any, any>) => (event: TraceStream) => Promise<void>;
+export declare const createTraceListener: (getReporter: () => TraceReporter, totalListener: number, handler: TraceHandler<any, any>) => (trace: TraceStream) => Promise<void>;