@fuzionx/framework 0.1.45 → 0.1.46

package/lib/core/Application.js

@@ -11,7 +11,7 @@ import path from 'node:path';
 import { promises as fs } from 'node:fs';
 import cluster from 'node:cluster';
 import Config from './Config.js';
-import Context from './Context.js';
+import Context, { createContext, createContextFromReq } from './Context.js';
 import Router from '../http/Router.js';
 import ModelRegistry from '../database/ModelRegistry.js';
 import ErrorHandler from '../http/ErrorHandler.js';
@@ -461,12 +461,15 @@ export default class Application {
             // WS proxy 연결 (WsHandler에서 this.app.ws 사용)
             if (!this.ws) this.ws = this._coreApp.ws;
 
-            this._registerBridgeRoutes(this._coreApp);
+            // ⚡ Raw dispatch 구축: Bridge에 직접 라우트 등록 + handlerId 디스패치 테이블
+            // Core의 createReq/createRes/runMiddlewareChain 파이프라인 완전 우회
+            this._buildRawDispatch();
 
             // WsHandler → Bridge WS 이벤트 연결
             this._registerWsHandlers(this._coreApp);
 
-            this._coreApp.listen(port, callback);
+            // Raw handler로 서버 시작 (Core _handleRequest 우회)
+            this._coreApp.listen(port, callback, (rawReq) => this._handleRawRequest(rawReq));
             // Bridge가 자체 graceful shutdown 처리 → Framework 중복 등록 불필요
         } else {
             // Bridge 미설치 (테스트 환경)
@@ -622,6 +625,170 @@ export default class Application {
         }
     }
 
+    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+    //  Raw Dispatch — Core 파이프라인 우회 (최적화 v3)
+    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+    /**
+     * Bridge에 직접 라우트 등록 + handlerId 기반 디스패치 테이블 구축
+     *
+     * ⚡ 최적화 핵심:
+     *   - Core의 Router/createReq/createRes/runMiddlewareChain 전체 우회
+     *   - Bridge에 직접 registerRoute → handlerId 획득
+     *   - handlerId → { resolvedHandler, middlewareFns, appName } 직접 매핑
+     *   - _handleRawRequest에서 O(1) 배열 인덱스로 디스패치
+     *
+     * @private
+     */
+    _buildRawDispatch() {
+        this._initControllers();
+
+        // handlerId는 1부터 순차 발급 → 배열 인덱스로 O(1) 조회 (Map 대신)
+        this._rawDispatch = [];
+        // Express :param → Rust {param} 변환
+        const toRustPath = (p) => p.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, '{$1}');
+        let nextId = 1;
+
+        // 멀티앱 Host 디스패치용: "METHOD:path" → Map<appName, entry>
+        const routeGroups = new Map();
+
+        for (const [appName, appEntry] of this._appRegistry) {
+            for (const route of appEntry.router.getRoutes()) {
+                const key = `${route.method}:${route.path}`;
+                if (!routeGroups.has(key)) routeGroups.set(key, new Map());
+
+                // 미들웨어 체인 사전 구성 (부트 시 1회)
+                const middlewareFns = [...this._globalMiddleware];
+                if (route.middleware?.length) {
+                    for (const mw of route.middleware) {
+                        if (typeof mw === 'function') {
+                            middlewareFns.push(mw);
+                        } else if (typeof mw === 'string') {
+                            const fn = this.resolveMiddleware(mw, appName);
+                            if (fn) middlewareFns.push(fn);
+                        }
+                    }
+                }
+
+                // ⚡ 핸들러 사전 바인딩 (런타임 Map 조회 0)
+                let resolvedHandler;
+                if (route.handler?.__handler__) {
+                    const instance = appEntry.controllerCache.get(route.handler.controller);
+                    if (instance && typeof instance[route.handler.method] === 'function') {
+                        resolvedHandler = instance[route.handler.method].bind(instance);
+                    }
+                } else if (typeof route.handler === 'function') {
+                    resolvedHandler = route.handler;
+                }
+
+                routeGroups.get(key).set(appName, { middlewareFns, resolvedHandler });
+            }
+        }
+
+        // Bridge에 직접 라우트 등록 + 디스패치 테이블 구축
+        for (const [key, appMap] of routeGroups) {
+            const colonIdx = key.indexOf(':');
+            const method = key.slice(0, colonIdx);
+            const routePath = key.slice(colonIdx + 1);
+            const rustPath = toRustPath(routePath);
+            const handlerId = nextId++;
+
+            // Rust Bridge에 직접 등록 (Core Router 우회)
+            this._bridge.registerRoute(method, rustPath, handlerId);
+
+            // 단일 앱 최적화: Host 디스패치 불필요
+            const isSingleApp = appMap.size === 1;
+            const singleEntry = isSingleApp ? appMap.values().next().value : null;
+            const singleAppName = isSingleApp ? appMap.keys().next().value : null;
+
+            // 배열 인덱스로 O(1) 조회 (Map.get 대신)
+            this._rawDispatch[handlerId] = {
+                appMap,
+                isSingleApp,
+                singleEntry,
+                singleAppName,
+            };
+        }
+
+        // 라우트 등록 완료 → Rust 라우터 빌드
+        this._bridge.buildRoutes();
+    }
+
+    /**
+     * Raw request 핸들러 — Core 파이프라인 완전 우회
+     *
+     * ⚡ 실행 경로:
+     *   Rust → rawReq → createContext(rawReq) → resolvedHandler(ctx) → _toFusionResponse()
+     *
+     * Core 경유 시 제거되는 비용:
+     *   - createReq: 14 프로퍼티 할당 (제거)
+     *   - createRes: Object.keys + delete + 4 할당 (제거)
+     *   - runMiddlewareChain: 클로저 생성 + 호출 (제거)
+     *   - ctx → res scalar 복사 (제거)
+     *
+     * @param {object} rawReq - Bridge에서 직접 전달받는 원시 요청
+     * @returns {object|{async:true}} Fusion 응답 객체 또는 async 마커
+     * @private
+     */
+    _handleRawRequest(rawReq) {
+        const dispatch = this._rawDispatch[rawReq.handlerId];
+        if (!dispatch) {
+            // handlerId 미등록 → 404
+            return { status: 404, body: '{"error":"Not Found"}', headers: { 'Content-Type': 'application/json' } };
+        }
+
+        // ── 앱 결정 (단일 앱: O(0), 멀티앱: Host 기반) ──
+        let appName, entry;
+        if (dispatch.isSingleApp) {
+            appName = dispatch.singleAppName;
+            entry = dispatch.singleEntry;
+        } else {
+            const host = rawReq.headers?.host || '';
+            appName = this._resolveApp(host, rawReq.headers);
+            entry = dispatch.appMap.get(appName);
+            if (!entry) entry = dispatch.appMap.get(this._getDefaultAppName());
+            if (!entry) entry = dispatch.appMap.values().next().value;
+        }
+
+        const { middlewareFns, resolvedHandler } = entry;
+
+        // ── rawReq → Context 직접 생성 (Core req/res 우회, 할당 최소화) ──
+        // ⚡ async 지원 시 클로저 포인터 공유 문제가 발생하므로 매 요청마다 새 컨텍스트 생성 (할당 비용 극소)
+        const ctx = createContext(rawReq, this, false);
+        ctx.appName = appName;
+
+        // ── Sync-first 실행 ──
+        let chainResult;
+        try {
+            if (middlewareFns.length === 0) {
+                // ⚡ 미들웨어 없음 → 핸들러 직접 호출
+                chainResult = resolvedHandler(ctx);
+            } else {
+                chainResult = this._executeSyncChain(middlewareFns, ctx, resolvedHandler);
+            }
+        } catch (err) {
+            this._handleContextError(err, ctx);
+            return ctx._toFusionResponse();
+        }
+
+        // ── sync 완료: 직접 Fusion 응답 반환 (중간 복사 0) ──
+        if (!chainResult || typeof chainResult.then !== 'function') {
+            return ctx._toFusionResponse();
+        }
+
+        // ── async 경로: Promise 대기 후 원래 Context로 응답 전송 ──
+        chainResult
+            .then(() => {
+                this._sendContextResponse(rawReq.requestId, ctx);
+            })
+            .catch((err) => {
+                this._handleContextError(err, ctx);
+                this._sendContextResponse(rawReq.requestId, ctx);
+            });
+
+        return { async: true };
+    }
+
     /**
      * 프레임워크 라우트 → Bridge 라우트 변환 (Host 기반 앱 디스패치)
      *
@@ -634,7 +801,7 @@ export default class Application {
     _registerBridgeRoutes(coreApp) {
         this._initControllers();
 
-        // 디스패치 테이블: "METHOD:path" → Map<appName, { route, middlewareFns }>
+        // 디스패치 테이블: "METHOD:path" → Map<appName, { route, middlewareFns, resolvedHandler }>
         const dispatch = new Map();
 
         for (const [appName, appEntry] of this._appRegistry) {
@@ -642,12 +809,10 @@ export default class Application {
                 const key = `${route.method}:${route.path}`;
                 if (!dispatch.has(key)) dispatch.set(key, new Map());
 
-                // 미들웨어 체인 사전 구성
+                // 미들웨어 체인 사전 구성 (배열 구성은 부트 시 1회만 실행)
                 const middlewareFns = [...this._globalMiddleware];
                 if (route.middleware?.length) {
                     for (const mw of route.middleware) {
-                        // 함수면 직접 사용 (built-in: auth(), cors() 등)
-                        // 문자열이면 resolveMiddleware로 클래스 기반 조회
                         if (typeof mw === 'function') {
                             middlewareFns.push(mw);
                         } else if (typeof mw === 'string') {
@@ -657,7 +822,20 @@ export default class Application {
                     }
                 }
 
-                dispatch.get(key).set(appName, { route, middlewareFns });
+                // ⚡ 핸들러 사전 바인딩 — 런타임 Map 조회 2회 → 직접 함수 호출 (부트 시 1회)
+                let resolvedHandler;
+                if (route.handler?.__handler__) {
+                    // 컨트롤러 메서드: appRegistry + controllerCache Map 조회를 부트 시 해결
+                    const instance = appEntry.controllerCache.get(route.handler.controller);
+                    if (instance && typeof instance[route.handler.method] === 'function') {
+                        resolvedHandler = instance[route.handler.method].bind(instance);
+                    }
+                } else if (typeof route.handler === 'function') {
+                    // 일반 함수 핸들러: 그대로 사용
+                    resolvedHandler = route.handler;
+                }
+
+                dispatch.get(key).set(appName, { route, middlewareFns, resolvedHandler });
             }
         }
 
@@ -725,88 +903,94 @@ export default class Application {
     }
 
     /**
-     * Host 기반 디스패치 핸들러 생성
+     * Host 기반 디스패치 핸들러 생성 (최적화 v2)
+     *
+     * ⚡ 최적화 핵심:
+     *   - createContextFromReq: 중간 객체 리터럴 제거 (Core req 직접 참조)
+     *   - 헤더 공유: ctx._headers = res._headers → _copyToRes 헤더 루프 제거
+     *   - 사전 바인딩: resolvedHandler → 런타임 Map 조회 0회
+     *   - 빈 미들웨어: middlewareFns.length === 0 → next() 함수 생성 스킵
      *
-     * 동일 path에 대해 Host 헤더로 앱을 결정하고
-     * 해당 앱의 route + middleware 체인을 실행.
+     * sync/async 분기:
+     *   - 미들웨어와 핸들러가 모두 sync → scalar 3개 복사 → Rust 즉시 write
+     *   - async 감지 → { async: true } + sendAsyncResponse
      *
-     * @param {Map<string, {route, middlewareFns}>} appMap - appName → {route, middlewareFns}
+     * @param {Map<string, {route, middlewareFns, resolvedHandler}>} appMap
      * @returns {Function} Bridge 핸들러
      * @private
      */
     _createDispatchHandler(appMap) {
+        // 단일 앱 최적화: appMap에 1개만 있으면 Host 라우팅 스킵
+        const isSingleApp = appMap.size === 1;
+        const singleEntry = isSingleApp ? appMap.values().next().value : null;
+        const singleAppName = isSingleApp ? appMap.keys().next().value : null;
+
         return (req, res) => {
-            // Host 헤더에서 앱 결정 (reverse proxy: X-Forwarded-Host 우선)
-            const host = req.headers?.host || req.headers?.Host || '';
-            const appName = this._resolveApp(host, req.headers);
-
-            // 해당 앱의 route+middleware 찾기 (없으면 기본 앱)
-            let entry = appMap.get(appName);
-            if (!entry) {
-                // 매칭 앱에 이 경로가 없으면 기본 앱 시도
-                const defaultApp = this._getDefaultAppName();
-                entry = appMap.get(defaultApp);
-            }
-            if (!entry) {
-                // 어떤 앱에도 없으면 첫 번째 앱
-                entry = appMap.values().next().value;
+            // ── 앱 결정 (단일 앱이면 O(0), 멀티앱이면 Host 기반) ──
+            let appName, entry;
+            if (isSingleApp) {
+                appName = singleAppName;
+                entry = singleEntry;
+            } else {
+                const host = req.headers?.host || '';
+                appName = this._resolveApp(host, req.headers);
+                entry = appMap.get(appName);
+                if (!entry) entry = appMap.get(this._getDefaultAppName());
+                if (!entry) entry = appMap.values().next().value;
             }
 
-            const { route, middlewareFns } = entry;
-
-            // rawReq → Context
-            const ctx = new Context({
-                method: req.method,
-                url: req.url,
-                path: req.path,
-                query: req.query,
-                params: req.params,
-                headers: req.headers,
-                body: req.body || req.json,
-                remoteIp: req.ip,
-                handlerId: req.handlerId,
-                requestId: req.requestId,
-                sessionId: req.sessionId,
-                session: req.session?._data || {},
-                files: req.files || null,
-                formFields: req.formFields || null,
-            }, this);
+            const { middlewareFns, resolvedHandler } = entry;
 
+            // ── Core req/res에서 직접 Context 생성 (중간 객체 할당 0) ──
+            const ctx = createContextFromReq(req, res, this, true);
             ctx.appName = appName;
 
-            // async 체인 실행 → sendAsyncResponse
-            const promise = this._executeChain(middlewareFns, route, ctx);
-
-            promise.then(() => {
-                const response = ctx.toResponse();
-                const contentType = response.headers?.['Content-Type'] || 'application/json';
-                const headerParts = [];
-                if (response.headers) {
-                    for (const [k, v] of Object.entries(response.headers)) {
-                        if (k !== 'Content-Type') headerParts.push(`${k}: ${v}`);
-                    }
-                }
-                const extraHeaders = headerParts.length > 0 ? headerParts.join('\r\n') + '\r\n' : '';
-                try {
-                    this._coreApp._bridge.sendAsyncResponse(
-                        req.requestId, response.status,
-                        response.body || '', contentType, extraHeaders,
-                    );
-                } catch (e) {
-                    console.error('[fuzionx] sendAsyncResponse failed:', e.message);
+            // ── Sync-first 실행 ──
+            let chainResult;
+            try {
+                if (middlewareFns.length === 0) {
+                    // ⚡ 미들웨어 없음 → next() 함수 생성 스킵, 핸들러 직접 호출
+                    chainResult = resolvedHandler(ctx);
+                } else {
+                    chainResult = this._executeSyncChain(middlewareFns, ctx, resolvedHandler);
                 }
-            }).catch((err) => {
-                console.error('[fuzionx] Handler error:', err.message || err);
-                try {
-                    this._coreApp._bridge.sendAsyncResponse(
-                        req.requestId, 500,
-                        JSON.stringify({ error: err.message || 'Internal Server Error' }),
-                        'application/json', '',
-                    );
-                } catch (e) {
-                    console.error('[fuzionx] sendAsyncResponse error failed:', e.message);
+            } catch (err) {
+                this._handleContextError(err, ctx);
+                // 헤더는 이미 공유 → scalar만 복사
+                res._statusCode = ctx._statusCode;
+                res._body = ctx._body;
+                res._sent = ctx._sent;
+                return;
+            }
+
+            // ── sync 완료: scalar 3개만 복사 (헤더는 이미 공유) ──
+            if (!chainResult || typeof chainResult.then !== 'function') {
+                res._statusCode = ctx._statusCode;
+                res._body = ctx._body;
+                res._sent = ctx._sent;
+                // Set-Cookie 병합 (공유 헤더에 직접 기록)
+                if (ctx._setCookies.length > 0) {
+                    ctx._headers['Set-Cookie'] = ctx._setCookies;
                 }
-            });
+                return; // Core가 res._toFusionResponse() 호출
+            }
+
+            // ── async 경로: 새 Context 인스턴스로 Promise 처리 ──
+            const asyncCtx = createContextFromReq(req, null, this, false);
+            asyncCtx.appName = appName;
+            asyncCtx._statusCode = ctx._statusCode;
+            asyncCtx._body = ctx._body;
+            asyncCtx._sent = ctx._sent;
+            asyncCtx.user = ctx.user;
+
+            chainResult
+                .then(() => {
+                    this._sendContextResponse(req.requestId, asyncCtx);
+                })
+                .catch((err) => {
+                    this._handleContextError(err, asyncCtx);
+                    this._sendContextResponse(req.requestId, asyncCtx);
+                });
 
             return { async: true };
         };
@@ -836,8 +1020,7 @@ export default class Application {
         }
 
         return (req, res) => {
-            // rawReq → Context 변환
-            const ctx = new Context({
+            const ctx = createContext({
                 method: req.method,
                 url: req.url,
                 path: req.path,
@@ -852,43 +1035,18 @@ export default class Application {
                 session: req.session?._data || {},
                 files: req.files || null,
                 formFields: req.formFields || null,
-            }, this);
+            }, this, false);
 
-            // 앱 이름 주입
             ctx.appName = appName;
 
-            // Framework → async 체인 실행 후 직접 sendAsyncResponse
+            // async 체인 실행 후 sendAsyncResponse
             const promise = this._executeChain(middlewareFns, route, ctx);
 
             promise.then(() => {
-                const response = ctx.toResponse();
-                const contentType = response.headers?.['Content-Type'] || 'application/json';
-                const headerParts = [];
-                if (response.headers) {
-                    for (const [k, v] of Object.entries(response.headers)) {
-                        if (k !== 'Content-Type') headerParts.push(`${k}: ${v}`);
-                    }
-                }
-                const extraHeaders = headerParts.length > 0 ? headerParts.join('\r\n') + '\r\n' : '';
-                try {
-                    this._coreApp._bridge.sendAsyncResponse(
-                        req.requestId, response.status,
-                        response.body || '', contentType, extraHeaders,
-                    );
-                } catch (e) {
-                    console.error('[fuzionx] sendAsyncResponse failed:', e.message);
-                }
+                this._sendContextResponse(req.requestId, ctx);
             }).catch((err) => {
-                console.error('[fuzionx] Handler error:', err.message || err);
-                try {
-                    this._coreApp._bridge.sendAsyncResponse(
-                        req.requestId, 500,
-                        JSON.stringify({ error: err.message || 'Internal Server Error' }),
-                        'application/json', '',
-                    );
-                } catch (e) {
-                    console.error('[fuzionx] sendAsyncResponse error failed:', e.message);
-                }
+                this._handleContextError(err, ctx);
+                this._sendContextResponse(req.requestId, ctx);
             });
 
             return { async: true };
@@ -896,64 +1054,193 @@ export default class Application {
     }
 
     /**
-     * 미들웨어 체인 + 핸들러 실행
+     * Sync-first 미들웨어 체인 + 핸들러 실행 (최적화 v2)
+     *
+     * flat loop으로 실행. 모든 미들웨어와 핸들러가 sync이면 Promise 생성 0.
+     * async 미들웨어/핸들러 감지 시 Promise를 반환하여 호출자에서 async 처리.
+     *
+     * @param {Function[]} middlewareFns - 미들웨어 함수 배열
+     * @param {object} ctx - Context 인스턴스
+     * @param {Function} resolvedHandler - 사전 바인딩된 핸들러 함수
+     * @returns {undefined|Promise} sync 완료 시 undefined, async 감지 시 Promise
      * @private
      */
-    async _executeChain(middlewareFns, route, ctx) {
+    _executeSyncChain(middlewareFns, ctx, resolvedHandler) {
         let idx = 0;
+        const len = middlewareFns.length;
 
-        const next = async () => {
+        /**
+         * next() — sync 우선 flat 호출
+         * 미들웨어가 Promise를 반환하면 체인 나머지를 async로 이어감
+         */
+        function next() {
             if (ctx._sent) return;
-            if (idx < middlewareFns.length) {
+
+            // 미들웨어 체인 순회
+            if (idx < len) {
                 const fn = middlewareFns[idx++];
-                await fn(ctx, next);
-                return;
+                const result = fn(ctx, next);
+                // async 미들웨어 감지 → Promise 전파
+                if (result && typeof result.then === 'function') {
+                    return result.catch((e) => {
+                        if (!ctx._sent) throw e;
+                    });
+                }
+                return result;
             }
 
-            // 미들웨어 완료 → 핸들러 실행
-            await this._executeHandler(route.handler, ctx);
-        };
+            // 미들웨어 완료 → 사전 바인딩된 핸들러 직접 호출 (Map 조회 0)
+            return resolvedHandler(ctx);
+        }
 
-        try {
-            await next();
-        } catch (err) {
-            // 커스텀 에러 핸들러 체크 (useError로 등록)
-            let handled = false;
-            for (const { path: ePath, handler } of this._errorHandlers) {
-                if (!ePath || ctx.path?.startsWith(ePath)) {
-                    try {
-                        await handler(err, ctx);
-                        handled = true;
-                        break;
-                    } catch { /* 커스텀 핸들러 실패 시 기본으로 */ }
-                }
-            }
-            if (!handled) this._errorHandler.handle(err, ctx);
+        return next();
+    }
+
+    /**
+     * Framework ctx 결과를 Core res 객체에 복사
+     *
+     * sync 경로에서 Core의 res._toFusionResponse()가 올바른 응답을 생성하도록:
+     * - _statusCode, _body, _headers, _sent를 Core res에 기록
+     * - Set-Cookie 헤더 병합
+     *
+     * @param {object} ctx - Framework Context 인스턴스
+     * @param {object} res - Core res 객체
+     * @private
+     */
+    _copyToRes(ctx, res) {
+        res._statusCode = ctx._statusCode;
+        res._body = ctx._body;
+        res._sent = ctx._sent;
+        // 헤더 복사: ctx._headers → res._headers
+        const ctxHeaders = ctx._headers;
+        const resHeaders = res._headers;
+        const keys = Object.keys(ctxHeaders);
+        for (let i = 0; i < keys.length; i++) {
+            resHeaders[keys[i]] = ctxHeaders[keys[i]];
+        }
+        // Set-Cookie 헤더 병합
+        if (ctx._setCookies && ctx._setCookies.length > 0) {
+            resHeaders['Set-Cookie'] = ctx._setCookies;
         }
-        // 응답은 _createBridgeHandler의 .then()에서 sendAsyncResponse로 전송
     }
 
     /**
-     * 핸들러 실행 (싱글톤 컨트롤러 or 일반 함수)
+     * 핸들러 실행 (sync 우선)
+     *
+     * 컨트롤러 메서드 또는 일반 함수를 실행.
+     * 반환값이 Promise이면 async 경로로 전파.
+     *
+     * @param {object|Function} handler - __handler__ 디스크립터 또는 일반 함수
+     * @param {object} ctx - Context 인스턴스
+     * @returns {undefined|Promise}
      * @private
      */
-    async _executeHandler(handler, ctx) {
+    _executeHandlerSync(handler, ctx) {
         if (handler?.__handler__) {
             // 앱별 싱글톤 컨트롤러 메서드 참조
             const appEntry = this._appRegistry.get(ctx.appName);
             const instance = appEntry?.controllerCache?.get(handler.controller);
             if (instance && typeof instance[handler.method] === 'function') {
-                await instance[handler.method](ctx);
-                return;
+                return instance[handler.method](ctx);
             }
         }
 
         // 일반 함수 핸들러
         if (typeof handler === 'function') {
-            await handler(ctx);
+            return handler(ctx);
         }
     }
 
+    /**
+     * Context 에러 핸들링 — ctx에 에러 응답 설정
+     * @param {Error} err - 발생한 에러
+     * @param {object} ctx - Context 인스턴스
+     * @private
+     */
+    _handleContextError(err, ctx) {
+        // 커스텀 에러 핸들러 체크 (useError로 등록)
+        for (const { path: ePath, handler } of this._errorHandlers) {
+            if (!ePath || ctx.path?.startsWith(ePath)) {
+                try {
+                    handler(err, ctx);
+                    return;
+                } catch { /* 커스텀 핸들러 실패 시 기본으로 */ }
+            }
+        }
+        this._errorHandler.handle(err, ctx);
+    }
+
+    /**
+     * Context 기반 async 응답 전송 — sendAsyncResponse 호출
+     *
+     * Object.keys for 루프로 헤더 조립 (Object.entries 대신 → 배열 할당 제거)
+     *
+     * @param {number} requestId - Bridge 요청 ID
+     * @param {object} ctx - Context 인스턴스
+     * @private
+     */
+    _sendContextResponse(requestId, ctx) {
+        const response = ctx._toFusionResponse();
+        const contentType = response.headers?.['Content-Type'] || 'application/json';
+
+        // 헤더 조립: Object.keys for 루프 (Object.entries 대신 → 배열 생성 제거)
+        let extraHeaders = '';
+        if (response.headers) {
+            const keys = Object.keys(response.headers);
+            for (let i = 0; i < keys.length; i++) {
+                const k = keys[i];
+                if (k !== 'Content-Type') {
+                    extraHeaders += k + ': ' + response.headers[k] + '\r\n';
+                }
+            }
+        }
+
+        try {
+            this._coreApp._bridge.sendAsyncResponse(
+                requestId, response.status,
+                response.body || '', contentType, extraHeaders,
+            );
+        } catch (e) {
+            console.error('[fuzionx] sendAsyncResponse failed:', e.message);
+        }
+    }
+
+    // ── 래거시 호환: async _executeChain (deprecated용 _createBridgeHandler에서 사용) ──
+
+    /**
+     * 미들웨어 체인 + 핸들러 실행 (async 래거시)
+     * @deprecated _executeSyncChain을 사용하세요. 이 메서드는 하위 호환용.
+     * @private
+     */
+    async _executeChain(middlewareFns, route, ctx) {
+        let idx = 0;
+
+        const next = async () => {
+            if (ctx._sent) return;
+            if (idx < middlewareFns.length) {
+                const fn = middlewareFns[idx++];
+                await fn(ctx, next);
+                return;
+            }
+            await this._executeHandlerSync(route.handler, ctx);
+        };
+
+        try {
+            await next();
+        } catch (err) {
+            this._handleContextError(err, ctx);
+        }
+    }
+
+    /**
+     * 핸들러 실행 (async 래거시 — 하위 호환)
+     * @deprecated _executeHandlerSync를 사용하세요.
+     * @private
+     */
+    async _executeHandler(handler, ctx) {
+        return this._executeHandlerSync(handler, ctx);
+    }
+
     // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
     //  Graceful Shutdown
     // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━