@fluojs/http 1.1.0 → 1.1.2

package/README.ko.md

@@ -41,6 +41,11 @@ class CreateUserDto {
   name!: string;
 }
 
+class FindUserParamsDto {
+  @FromPath('id')
+  id!: string;
+}
+
 @Controller('/users')
 export class UserController {
   @Post('/')
@@ -50,8 +55,9 @@ export class UserController {
   }
 
   @Get('/:id')
-  getById(@FromPath('id') id: string) {
-    return { id, name: 'John Doe' };
+  @RequestDto(FindUserParamsDto)
+  getById(input: FindUserParamsDto) {
+    return { id: input.id, name: 'John Doe' };
   }
 }
 ```
@@ -96,7 +102,7 @@ function someDeepHelper() {
 }
 ```
 
-`runWithRequestContext(...)`는 호스트가 `globalThis.AsyncLocalStorage` 또는 Node 내장 `node:async_hooks` 모듈로 `AsyncLocalStorage`를 제공할 때 활성 컨텍스트를 `await` 이후까지 보존합니다. 선언된 `>=20.0.0` 지원 범위의 Node 런타임은 `process.getBuiltinModule(...)`이 없어도 `node:async_hooks`를 동적으로 해석해 ALS 의미론을 유지합니다. 비동기 컨텍스트 primitive가 없는 비 Node 호스트에서는 동기 stack fallback을 사용하며, 겹치는 비동기 요청이 서로의 컨텍스트를 관찰하지 않도록 awaited continuation이 재개되기 전에 컨텍스트를 비웁니다.
+`runWithRequestContext(...)`는 호스트가 `globalThis.AsyncLocalStorage` 또는 Node 내장 `node:async_hooks` 모듈로 `AsyncLocalStorage`를 제공할 때 활성 컨텍스트를 `await` 이후까지 보존합니다. 루트 `@fluojs/http` import는 async-context storage를 probe하거나 instantiate하지 않습니다. Helper가 처음 사용될 때 storage를 lazy하게 해석하고, `process.getBuiltinModule(...)` 실패를 guard하며, Node async storage 해석이 끝나기 전에 등록된 promise continuation도 격리하면서 첫 호출의 동기 callback 반환 및 throw 동작은 그대로 유지합니다. 비동기 컨텍스트 primitive가 없는 비 Node 호스트에서는 동기 stack fallback을 사용하며, 겹치는 비동기 요청이 서로의 컨텍스트를 관찰하지 않도록 awaited continuation이 재개되기 전에 컨텍스트를 비웁니다.
 
 ### 프록시 뒤의 속도 제한
 
@@ -180,7 +186,7 @@ Fluo의 HTTP 데코레이터는 TC39 표준 데코레이터이며, runtime 또
 
 디스패처는 활성 dispatch 동안에만 호스트 비동기 컨텍스트 저장소로 `RequestContext`를 바인딩합니다. 지원되는 Node 20+ 런타임을 포함해 `AsyncLocalStorage`가 있는 호스트에서는 컨텍스트가 awaited work 이후까지 유지됩니다. 비동기 컨텍스트 primitive가 없는 비 Node 호스트에서는 fallback 컨텍스트가 동기 프레임에만 유효하고, 겹치는 요청이 서로의 컨텍스트를 관찰하지 않도록 `await` 이후에는 의도적으로 사용할 수 없습니다. 요청이 controller graph, middleware, guard, interceptor, observer, DTO converter, custom binder 또는 수동 `getCurrentRequestContext()` / `assertRequestContext()` container 접근을 통해 request-scoped DI를 사용할 수 있으면, 디스패처는 요청 observer가 끝난 뒤 `finally` 경로에서 isolated request-scoped DI 컨테이너를 생성하고 dispose합니다. Singleton-only route는 `RequestContext.container`가 접근되기 전까지 이 컨테이너 lifecycle을 건너뛰어 baseline 경로의 불필요한 per-request allocation을 피하면서도, graph가 모호하거나 request-scoped이면 request-scoped provider isolation을 유지합니다. 따라서 공개 `RequestContext.container` 읽기는 request-scoped provider resolve에 항상 안전합니다. singleton-only fast path는 내부 dispatcher 최적화일 뿐, 공개 context가 root container를 노출한다는 약속이 아닙니다.
 
-어댑터는 플랫폼이 제공한다면 `FrameworkRequest.signal`에 `AbortSignal`을 전달해야 합니다. SSE에서는 가능하면 `FrameworkResponse.stream.onClose(...)`도 노출해야 합니다. `SseResponse`는 request abort와 raw stream close를 모두 구독하고, 멱등하게 닫히며, 어느 쪽이 먼저 종료되더라도 등록한 listener를 제거합니다.
+어댑터는 플랫폼이 제공한다면 `FrameworkRequest.signal`에 `AbortSignal`을 전달하고, signal allocation이 실용적이지 않다면 `isAborted()` probe를 제공해야 합니다. Dispatcher는 per-dispatch request clone에 두 abort surface를 모두 보존하고 handler 작업 전후에 검사하므로 `AbortSignal`이 없는 어댑터도 abandon된 요청을 중단할 수 있습니다. SSE에서는 가능하면 `FrameworkResponse.stream.onClose(...)`도 노출해야 합니다. `SseResponse`는 request abort와 raw stream close를 모두 구독하고, 멱등하게 닫히며, 어느 쪽이 먼저 종료되더라도 등록한 listener를 제거합니다.
 
 ## 공개 API
 

package/README.md

@@ -43,6 +43,11 @@ class CreateUserDto {
   name!: string;
 }
 
+class FindUserParamsDto {
+  @FromPath('id')
+  id!: string;
+}
+
 @Controller('/users')
 export class UserController {
   @Post('/')
@@ -52,8 +57,9 @@ export class UserController {
   }
 
   @Get('/:id')
-  getById(@FromPath('id') id: string) {
-    return { id, name: 'John Doe' };
+  @RequestDto(FindUserParamsDto)
+  getById(input: FindUserParamsDto) {
+    return { id: input.id, name: 'John Doe' };
   }
 }
 ```
@@ -98,7 +104,7 @@ function someDeepHelper() {
 }
 ```
 
-`runWithRequestContext(...)` preserves the active context across awaited work when the host provides `AsyncLocalStorage` through `globalThis.AsyncLocalStorage` or Node's built-in `node:async_hooks` module. Node runtimes in the declared `>=20.0.0` support range keep ALS semantics even when `process.getBuiltinModule(...)` is unavailable by resolving `node:async_hooks` dynamically. Non-Node hosts without an async-context primitive use a synchronous stack fallback that clears the context before awaited continuations resume, avoiding cross-request leaks instead of pretending to isolate overlapping async work.
+`runWithRequestContext(...)` preserves the active context across awaited work when the host provides `AsyncLocalStorage` through `globalThis.AsyncLocalStorage` or Node's built-in `node:async_hooks` module. The root `@fluojs/http` import does not probe or instantiate async-context storage; helpers resolve storage lazily on first use, guard `process.getBuiltinModule(...)` failures, and keep the first-call synchronous callback return and throw behavior unchanged while isolating promise continuations registered before Node async storage finishes resolving. Non-Node hosts without an async-context primitive use a synchronous stack fallback that clears the context before awaited continuations resume, avoiding cross-request leaks instead of pretending to isolate overlapping async work.
 
 ### Rate limiting behind proxies
 
@@ -182,7 +188,7 @@ This compatibility path is an execution fallback for Bun bundle output; applicat
 
 The dispatcher binds `RequestContext` with host async-context storage for the active dispatch only. On hosts with `AsyncLocalStorage`, including supported Node 20+ runtimes, the context remains available across awaited work. On non-Node hosts without an async-context primitive, the fallback context is synchronous-only and intentionally unavailable after `await` so overlapping requests cannot observe one another's context. When a request may use request-scoped DI through its controller graph, middleware, guards, interceptors, observers, DTO converters, a custom binder, or manual `getCurrentRequestContext()` / `assertRequestContext()` container access, the dispatcher creates and disposes an isolated request-scoped DI container from its `finally` path after request observers finish. Singleton-only routes skip that container lifecycle until `RequestContext.container` is accessed, so the baseline path avoids unnecessary per-request allocation while preserving request-scoped provider isolation whenever the graph is ambiguous or request-scoped. Public `RequestContext.container` reads are therefore always safe for resolving request-scoped providers; the singleton-only fast path is an internal dispatcher optimization, not a promise that the public context exposes the root container.
 
-Adapters should pass an `AbortSignal` on `FrameworkRequest.signal` when the platform exposes one. For SSE, adapters should also expose `FrameworkResponse.stream.onClose(...)` when possible; `SseResponse` listens to both request abort and raw stream close, closes idempotently, and removes registered listeners when either side terminates first.
+Adapters should pass an `AbortSignal` on `FrameworkRequest.signal` when the platform exposes one, or an `isAborted()` probe when allocating a signal is not practical. The dispatcher preserves both abort surfaces on its per-dispatch request clone and checks them before and after handler work so adapters without `AbortSignal` can still stop abandoned requests. For SSE, adapters should also expose `FrameworkResponse.stream.onClose(...)` when possible; `SseResponse` listens to both request abort and raw stream close, closes idempotently, and removes registered listeners when either side terminates first.
 
 ## Public API
 

package/dist/context/request-context-node-store.d.ts

@@ -13,6 +13,13 @@ type AsyncLocalStorageResolutionHost = {
     };
 };
 type NodeAsyncHooksLoader = () => Promise<NodeAsyncHooksModule>;
+/**
+ * Resolves host-provided `AsyncLocalStorage` without async imports or throwing host probes.
+ *
+ * @param host Host global-like object to inspect for synchronous async-context support.
+ * @returns The resolved `AsyncLocalStorage` constructor, or `undefined` when unavailable.
+ */
+export declare function resolveImmediateAsyncLocalStorageConstructor(host?: AsyncLocalStorageResolutionHost): AsyncLocalStorageConstructor | undefined;
 /**
  * Resolves the host `AsyncLocalStorage` constructor without eagerly importing Node built-ins.
  *
@@ -21,5 +28,12 @@ type NodeAsyncHooksLoader = () => Promise<NodeAsyncHooksModule>;
  * @returns The resolved `AsyncLocalStorage` constructor, or `undefined` when unavailable.
  */
 export declare function resolveAsyncLocalStorageConstructor(host?: AsyncLocalStorageResolutionHost, loadNodeAsyncHooks?: NodeAsyncHooksLoader): Promise<AsyncLocalStorageConstructor | undefined>;
+/**
+ * Reports whether the host can still resolve Node async-context storage asynchronously.
+ *
+ * @param host Host global-like object to inspect for Node runtime markers.
+ * @returns `true` when the host is Node.js and can use a lazy `node:async_hooks` import.
+ */
+export declare function canResolveAsyncLocalStorageDynamically(host?: AsyncLocalStorageResolutionHost): boolean;
 export {};
 //# sourceMappingURL=request-context-node-store.d.ts.map

package/dist/context/request-context-node-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"request-context-node-store.d.ts","sourceRoot":"","sources":["../../src/context/request-context-node-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEtE,KAAK,4BAA4B,GAAG,UAAU,mBAAmB,CAAC;AAElE,KAAK,oBAAoB,GAAG;IAC1B,iBAAiB,CAAC,EAAE,4BAA4B,CAAC;CAClD,CAAC;AAEF,KAAK,+BAA+B,GAAG;IACrC,iBAAiB,CAAC,EAAE,4BAA4B,CAAC;IACjD,OAAO,CAAC,EAAE;QACR,gBAAgB,CAAC,CAAC,EAAE,EAAE,kBAAkB,GAAG,oBAAoB,CAAC;QAChE,QAAQ,CAAC,EAAE;YACT,IAAI,CAAC,EAAE,MAAM,CAAC;SACf,CAAC;KACH,CAAC;CACH,CAAC;AAEF,KAAK,oBAAoB,GAAG,MAAM,OAAO,CAAC,oBAAoB,CAAC,CAAC;AAEhE;;;;;;GAMG;AACH,wBAAsB,mCAAmC,CACvD,IAAI,GAAE,+BAA4C,EAClD,kBAAkB,GAAE,oBAA2C,GAC9D,OAAO,CAAC,4BAA4B,GAAG,SAAS,CAAC,CAsBnD"}
+{"version":3,"file":"request-context-node-store.d.ts","sourceRoot":"","sources":["../../src/context/request-context-node-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEtE,KAAK,4BAA4B,GAAG,UAAU,mBAAmB,CAAC;AAElE,KAAK,oBAAoB,GAAG;IAC1B,iBAAiB,CAAC,EAAE,4BAA4B,CAAC;CAClD,CAAC;AAEF,KAAK,+BAA+B,GAAG;IACrC,iBAAiB,CAAC,EAAE,4BAA4B,CAAC;IACjD,OAAO,CAAC,EAAE;QACR,gBAAgB,CAAC,CAAC,EAAE,EAAE,kBAAkB,GAAG,oBAAoB,CAAC;QAChE,QAAQ,CAAC,EAAE;YACT,IAAI,CAAC,EAAE,MAAM,CAAC;SACf,CAAC;KACH,CAAC;CACH,CAAC;AAEF,KAAK,oBAAoB,GAAG,MAAM,OAAO,CAAC,oBAAoB,CAAC,CAAC;AAEhE;;;;;GAKG;AACH,wBAAgB,4CAA4C,CAC1D,IAAI,GAAE,+BAA4C,GACjD,4BAA4B,GAAG,SAAS,CAsB1C;AAED;;;;;;GAMG;AACH,wBAAsB,mCAAmC,CACvD,IAAI,GAAE,+BAA4C,EAClD,kBAAkB,GAAE,oBAA2C,GAC9D,OAAO,CAAC,4BAA4B,GAAG,SAAS,CAAC,CAkBnD;AAED;;;;;GAKG;AACH,wBAAgB,sCAAsC,CACpD,IAAI,GAAE,+BAA4C,GACjD,OAAO,CAET"}

package/dist/context/request-context-node-store.js

@@ -1,3 +1,28 @@
+/**
+ * Resolves host-provided `AsyncLocalStorage` without async imports or throwing host probes.
+ *
+ * @param host Host global-like object to inspect for synchronous async-context support.
+ * @returns The resolved `AsyncLocalStorage` constructor, or `undefined` when unavailable.
+ */
+export function resolveImmediateAsyncLocalStorageConstructor(host = globalThis) {
+  if (typeof host.AsyncLocalStorage === 'function') {
+    return host.AsyncLocalStorage;
+  }
+  const getBuiltinModule = host.process?.getBuiltinModule;
+  if (typeof getBuiltinModule !== 'function') {
+    return undefined;
+  }
+  try {
+    const builtinAsyncLocalStorage = getBuiltinModule('node:async_hooks')?.AsyncLocalStorage;
+    if (typeof builtinAsyncLocalStorage === 'function') {
+      return builtinAsyncLocalStorage;
+    }
+  } catch {
+    return undefined;
+  }
+  return undefined;
+}
+
 /**
  * Resolves the host `AsyncLocalStorage` constructor without eagerly importing Node built-ins.
  *
@@ -6,12 +31,9 @@
  * @returns The resolved `AsyncLocalStorage` constructor, or `undefined` when unavailable.
  */
 export async function resolveAsyncLocalStorageConstructor(host = globalThis, loadNodeAsyncHooks = importNodeAsyncHooks) {
-  if (typeof host.AsyncLocalStorage === 'function') {
-    return host.AsyncLocalStorage;
-  }
-  const builtinAsyncLocalStorage = host.process?.getBuiltinModule?.('node:async_hooks').AsyncLocalStorage;
-  if (typeof builtinAsyncLocalStorage === 'function') {
-    return builtinAsyncLocalStorage;
+  const immediateAsyncLocalStorage = resolveImmediateAsyncLocalStorageConstructor(host);
+  if (typeof immediateAsyncLocalStorage === 'function') {
+    return immediateAsyncLocalStorage;
   }
   if (!isNodeHost(host)) {
     return undefined;
@@ -23,6 +45,16 @@ export async function resolveAsyncLocalStorageConstructor(host = globalThis, loa
     return undefined;
   }
 }
+
+/**
+ * Reports whether the host can still resolve Node async-context storage asynchronously.
+ *
+ * @param host Host global-like object to inspect for Node runtime markers.
+ * @returns `true` when the host is Node.js and can use a lazy `node:async_hooks` import.
+ */
+export function canResolveAsyncLocalStorageDynamically(host = globalThis) {
+  return isNodeHost(host);
+}
 function isNodeHost(host) {
   return typeof host.process?.versions?.node === 'string';
 }

package/dist/context/request-context.d.ts

@@ -2,9 +2,11 @@ import type { ContextKey, RequestContext } from '../types.js';
 /**
  * Runs a callback inside the request-scoped async context.
  *
- * Hosts with `AsyncLocalStorage` preserve the context across awaited work. Hosts without an async
- * context primitive use a stack fallback that keeps the context only for the synchronous callback
- * frame and clears it before awaited continuations resume.
+ * Hosts with `AsyncLocalStorage` preserve the context across awaited work. During lazy
+ * `AsyncLocalStorage` resolution, promise continuations registered before the store resolves keep
+ * their request context until the returned promise settles. Hosts without an async context primitive
+ * use a stack fallback that keeps the context only for the synchronous callback frame and clears it
+ * before awaited continuations resume.
  *
  * @param context Request context snapshot to bind to the current async execution chain.
  * @param callback Callback executed with `context` available through request-context helpers.

package/dist/context/request-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"request-context.d.ts","sourceRoot":"","sources":["../../src/context/request-context.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAO9D;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,CAEtF;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,IAAI,cAAc,GAAG,SAAS,CAErE;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,IAAI,cAAc,CAUrD;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,cAAc,GAAG,cAAc,CAK5E;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,WAAW,EAAE,MAAM,GAAG,UAAU,CAAC,CAAC,CAAC,CAKtE;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,cAAc,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,SAAS,CAE7F;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,cAAc,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAE9F"}
+{"version":3,"file":"request-context.d.ts","sourceRoot":"","sources":["../../src/context/request-context.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAoB9D;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,CAgBtF;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,IAAI,cAAc,GAAG,SAAS,CAErE;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,IAAI,cAAc,CAUrD;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,cAAc,GAAG,cAAc,CAK5E;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,WAAW,EAAE,MAAM,GAAG,UAAU,CAAC,CAAC,CAAC,CAKtE;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,cAAc,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,SAAS,CAE7F;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,cAAc,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAE9F"}

package/dist/context/request-context.js

@@ -1,21 +1,37 @@
 import { FluoError } from '@fluojs/core';
-import { resolveAsyncLocalStorageConstructor } from './request-context-node-store.js';
+import { canResolveAsyncLocalStorageDynamically, resolveAsyncLocalStorageConstructor, resolveImmediateAsyncLocalStorageConstructor } from './request-context-node-store.js';
 import { createStackRequestContextStore } from './request-context-stack-store.js';
-const requestContextStore = await createRequestContextStore();
-
+let requestContextStore;
+let requestContextStoreResolution;
+let fallbackRequestContextStore;
+let originalPromiseThen;
+let promiseThenPatchDepth = 0;
+const dynamicResolutionFallbackStack = [];
 /**
  * Runs a callback inside the request-scoped async context.
  *
- * Hosts with `AsyncLocalStorage` preserve the context across awaited work. Hosts without an async
- * context primitive use a stack fallback that keeps the context only for the synchronous callback
- * frame and clears it before awaited continuations resume.
+ * Hosts with `AsyncLocalStorage` preserve the context across awaited work. During lazy
+ * `AsyncLocalStorage` resolution, promise continuations registered before the store resolves keep
+ * their request context until the returned promise settles. Hosts without an async context primitive
+ * use a stack fallback that keeps the context only for the synchronous callback frame and clears it
+ * before awaited continuations resume.
  *
  * @param context Request context snapshot to bind to the current async execution chain.
  * @param callback Callback executed with `context` available through request-context helpers.
  * @returns The return value from `callback`.
  */
 export function runWithRequestContext(context, callback) {
-  return requestContextStore.run(context, callback);
+  const store = getResolvedRequestContextStore();
+  if (store) {
+    return store.run(context, callback);
+  }
+  if (!canResolveAsyncLocalStorageDynamically()) {
+    return getFallbackRequestContextStore().run(context, callback);
+  }
+  if (!isAsyncCallback(callback)) {
+    return runWithDynamicResolutionFallbackContext(context, callback);
+  }
+  return runWithResolvedRequestContextStore(context, callback);
 }
 
 /**
@@ -24,7 +40,7 @@ export function runWithRequestContext(context, callback) {
  * @returns The active request context, or `undefined` when no request scope is bound.
  */
 export function getCurrentRequestContext() {
-  return requestContextStore.getStore();
+  return getRequestContextStore().getStore() ?? getDynamicResolutionFallbackContext();
 }
 
 /**
@@ -92,10 +108,115 @@ export function getContextValue(context, key) {
 export function setContextValue(context, key, value) {
   context.metadata[key.id] = value;
 }
+function getRequestContextStore() {
+  return getResolvedRequestContextStore() ?? getFallbackRequestContextStore();
+}
+function getResolvedRequestContextStore() {
+  if (requestContextStore) {
+    return requestContextStore;
+  }
+  const AsyncLocalStorage = resolveImmediateAsyncLocalStorageConstructor();
+  if (typeof AsyncLocalStorage === 'function') {
+    requestContextStore = new AsyncLocalStorage();
+    return requestContextStore;
+  }
+  void resolveRequestContextStore();
+  return undefined;
+}
+async function runWithResolvedRequestContextStore(context, callback) {
+  const store = await resolveRequestContextStore();
+  return store.run(context, callback);
+}
+async function resolveRequestContextStore() {
+  requestContextStoreResolution ??= createRequestContextStore();
+  return requestContextStoreResolution;
+}
 async function createRequestContextStore() {
   const AsyncLocalStorage = await resolveAsyncLocalStorageConstructor();
   if (typeof AsyncLocalStorage === 'function') {
-    return new AsyncLocalStorage();
+    requestContextStore = new AsyncLocalStorage();
+    return requestContextStore;
+  }
+  requestContextStore = getFallbackRequestContextStore();
+  return requestContextStore;
+}
+function getFallbackRequestContextStore() {
+  fallbackRequestContextStore ??= createStackRequestContextStore();
+  return fallbackRequestContextStore;
+}
+function runWithDynamicResolutionFallbackContext(context, callback) {
+  dynamicResolutionFallbackStack.push(context);
+  installPromiseThenContextBridge();
+  let cleanedUp = false;
+  const cleanup = () => {
+    if (cleanedUp) {
+      return;
+    }
+    cleanedUp = true;
+    removeDynamicResolutionFallbackContext(context);
+    restorePromiseThenContextBridge();
+    void resolveRequestContextStore();
+  };
+  try {
+    const result = callback();
+    if (isPromise(result)) {
+      const then = originalPromiseThen ?? Promise.prototype.then;
+      void then.call(result, cleanup, cleanup);
+      return result;
+    }
+    cleanup();
+    return result;
+  } catch (error) {
+    cleanup();
+    throw error;
+  }
+}
+function getDynamicResolutionFallbackContext() {
+  return dynamicResolutionFallbackStack.at(-1);
+}
+function removeDynamicResolutionFallbackContext(context) {
+  const index = dynamicResolutionFallbackStack.lastIndexOf(context);
+  if (index >= 0) {
+    dynamicResolutionFallbackStack.splice(index, 1);
+  }
+}
+function installPromiseThenContextBridge() {
+  if (promiseThenPatchDepth === 0) {
+    originalPromiseThen = Promise.prototype.then;
+    Object.defineProperty(Promise.prototype, 'then', {
+      configurable: true,
+      value: createContextBridgePromiseThen(originalPromiseThen),
+      writable: true
+    });
+  }
+  promiseThenPatchDepth += 1;
+}
+function restorePromiseThenContextBridge() {
+  promiseThenPatchDepth -= 1;
+  if (promiseThenPatchDepth === 0 && originalPromiseThen) {
+    Object.defineProperty(Promise.prototype, 'then', {
+      configurable: true,
+      value: originalPromiseThen,
+      writable: true
+    });
+    originalPromiseThen = undefined;
+  }
+}
+function createContextBridgePromiseThen(originalThen) {
+  return function contextBridgePromiseThen(onfulfilled, onrejected) {
+    const context = getDynamicResolutionFallbackContext();
+    return originalThen.call(this, wrapPromiseCallback(context, onfulfilled), wrapPromiseCallback(context, onrejected));
+  };
+}
+function wrapPromiseCallback(context, callback) {
+  if (!context || typeof callback !== 'function') {
+    return callback;
   }
-  return createStackRequestContextStore();
+  return value => runWithDynamicResolutionFallbackContext(context, () => callback(value));
+}
+function isPromise(value) {
+  return value instanceof Promise;
+}
+function isAsyncCallback(callback) {
+  return callback.constructor.name === 'AsyncFunction';
 }

package/dist/dispatch/dispatcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dispatcher.d.ts","sourceRoot":"","sources":["../../src/dispatch/dispatcher.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAyB,MAAM,YAAY,CAAC;AAQnE,OAAO,KAAK,EACV,MAAM,EACN,yBAAyB,EACzB,aAAa,EACb,UAAU,EACV,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EAKjB,cAAc,EAEd,eAAe,EAEf,cAAc,EAId,mBAAmB,EACpB,MAAM,aAAa,CAAC;AAKrB,OAAO,EAKL,KAAK,aAAa,EAOnB,MAAM,sBAAsB,CAAC;AAE9B,YAAY,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC/E,OAAO,EAAE,4BAA4B,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAE5F,gEAAgE;AAChE,MAAM,MAAM,YAAY,GAAG,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,gBAAgB,EAAE,QAAQ,EAAE,iBAAiB,EAAE,SAAS,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,OAAO,GAAG,IAAI,CAAC;AAEpK,uDAAuD;AACvD,MAAM,WAAW,uBAAuB;IACtC,iDAAiD;IACjD,aAAa,CAAC,EAAE,cAAc,EAAE,CAAC;IACjC,kFAAkF;IAClF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kDAAkD;IAClD,kBAAkB,CAAC,EAAE,yBAAyB,CAAC;IAC/C,sDAAsD;IACtD,cAAc,EAAE,cAAc,CAAC;IAC/B,2DAA2D;IAC3D,YAAY,CAAC,EAAE,eAAe,EAAE,CAAC;IACjC,0DAA0D;IAC1D,SAAS,CAAC,EAAE,mBAAmB,EAAE,CAAC;IAClC,+DAA+D;IAC/D,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,qCAAqC;IACrC,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,sEAAsE;IACtE,YAAY,CAAC,EAAE;QACb,wDAAwD;QACxD,oBAAoB,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;KACjD,CAAC;IACF,qDAAqD;IACrD,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,qDAAqD;IACrD,aAAa,EAAE,SAAS,CAAC;IACzB,+EAA+E;IAC/E,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAy8BD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,UAAU,CAuF7E;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,UAAU,GAAG,aAAa,GAAG,SAAS,CAE5F;AAED,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC"}
+{"version":3,"file":"dispatcher.d.ts","sourceRoot":"","sources":["../../src/dispatch/dispatcher.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAyB,MAAM,YAAY,CAAC;AAQnE,OAAO,KAAK,EACV,MAAM,EACN,yBAAyB,EACzB,aAAa,EACb,UAAU,EACV,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EAKjB,cAAc,EAEd,eAAe,EAEf,cAAc,EAId,mBAAmB,EACpB,MAAM,aAAa,CAAC;AAKrB,OAAO,EAKL,KAAK,aAAa,EAOnB,MAAM,sBAAsB,CAAC;AAE9B,YAAY,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC/E,OAAO,EAAE,4BAA4B,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAE5F,gEAAgE;AAChE,MAAM,MAAM,YAAY,GAAG,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,gBAAgB,EAAE,QAAQ,EAAE,iBAAiB,EAAE,SAAS,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,OAAO,GAAG,IAAI,CAAC;AAEpK,uDAAuD;AACvD,MAAM,WAAW,uBAAuB;IACtC,iDAAiD;IACjD,aAAa,CAAC,EAAE,cAAc,EAAE,CAAC;IACjC,kFAAkF;IAClF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kDAAkD;IAClD,kBAAkB,CAAC,EAAE,yBAAyB,CAAC;IAC/C,sDAAsD;IACtD,cAAc,EAAE,cAAc,CAAC;IAC/B,2DAA2D;IAC3D,YAAY,CAAC,EAAE,eAAe,EAAE,CAAC;IACjC,0DAA0D;IAC1D,SAAS,CAAC,EAAE,mBAAmB,EAAE,CAAC;IAClC,+DAA+D;IAC/D,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,qCAAqC;IACrC,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,sEAAsE;IACtE,YAAY,CAAC,EAAE;QACb,wDAAwD;QACxD,oBAAoB,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;KACjD,CAAC;IACF,qDAAqD;IACrD,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,qDAAqD;IACrD,aAAa,EAAE,SAAS,CAAC;IACzB,+EAA+E;IAC/E,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AA08BD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,UAAU,CAuF7E;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,UAAU,GAAG,aAAa,GAAG,SAAS,CAE5F;AAED,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/dispatch/dispatcher.js

@@ -45,6 +45,7 @@ function createDispatchRequest(request) {
     raw: request.raw,
     rawBody: request.rawBody,
     requestId: request.requestId,
+    isAborted: request.isAborted,
     signal: request.signal,
     url: request.url
   };

package/package.json

@@ -10,7 +10,7 @@
     "controller",
     "rest"
   ],
-  "version": "1.1.0",
+  "version": "1.1.2",
   "private": false,
   "license": "MIT",
   "repository": {
@@ -42,8 +42,8 @@
   ],
   "dependencies": {
     "@fluojs/core": "^1.0.3",
-    "@fluojs/validation": "^1.0.4",
-    "@fluojs/di": "^1.0.3"
+    "@fluojs/validation": "^1.0.5",
+    "@fluojs/di": "^1.1.0"
   },
   "devDependencies": {
     "vitest": "^3.2.4"