@fluojs/mongoose 1.0.5 → 1.1.1

package/README.ko.md

@@ -11,6 +11,9 @@
 - [빠른 시작](#빠른-시작)
 - [라이프사이클과 종료](#라이프사이클과-종료)
 - [공통 패턴](#공통-패턴)
+  - [서비스 트랜잭션 경계 (@Transaction)](#서비스-트랜잭션-경계-transaction)
+  - [요청 트랜잭션 인터셉터 호환성](#요청-트랜잭션-인터셉터-호환성)
+  - [수동 트랜잭션과 currentSession()](#수동-트랜잭션과-currentsession)
 - [공개 API](#공개-api)
 - [관련 패키지](#관련-패키지)
 - [예제 소스](#예제-소스)
@@ -26,7 +29,10 @@ pnpm add mongoose
 
 - Mongoose를 나머지 애플리케이션과 같은 DI 및 라이프사이클 모델에 연결하고 싶을 때.
 - 모든 서비스에서 MongoDB 세션과 트랜잭션을 임시 배관 코드 없이 하나의 wrapper로 다루고 싶을 때.
-- 요청 범위 트랜잭션을 interceptor로 명시적으로 켜고 싶을 때.
+- 요청 단위 트랜잭션에 명시적 `requestTransaction(...)` 경계가 필요할 때.
+- 애플리케이션이 이미 concrete Mongoose connection을 생성·구성하고 있고, fluo가 그 ownership을 대체하지 않고 관측하기를 원할 때.
+
+Root `@fluojs/mongoose` wrapper는 ambient transaction context에 Node.js `node:async_hooks`를 사용하며, package manifest의 `engines.node >=20.0.0`과 동일하게 Node.js 20 이상을 지원합니다. 비 Node 런타임에서는 runtime-specific transaction-context adapter가 문서화되기 전까지 root wrapper를 import하지 말고 raw Mongoose-compatible handle을 애플리케이션 소유 provider 뒤에 등록하세요.
 
 ## 빠른 시작
 
@@ -54,78 +60,129 @@ class AppModule {}
 
 ## 라이프사이클과 종료
 
-`MongooseModule`은 `MongooseConnection`을 fluo 애플리케이션 라이프사이클에 등록합니다. 이 패키지는 원본 Mongoose 연결을 직접 생성하거나 소유하지 않습니다. 애플리케이션 종료 시 외부 연결을 닫아야 한다면 `dispose` 훅을 전달하세요.
+`MongooseModule`은 `MongooseConnection`을 fluo 애플리케이션 라이프사이클에 등록합니다. 이 패키지는 원본 Mongoose 연결을 직접 생성하거나 소유하지 않습니다. `connection`에는 concrete Mongoose connection object/function을 전달하고, 연결 문자열, pool, plugin, model compilation ownership은 애플리케이션에 남겨두며, 애플리케이션 종료 시 외부 연결을 닫아야 한다면 `dispose` 훅을 전달하세요.
 
-종료 과정은 트랜잭션 정리 순서를 보존하며, 종료가 시작된 뒤에는 새 수동 또는 요청 범위 트랜잭션 경계를 거부합니다.
+종료 절차는 트랜잭션 정리 순서를 보존하고, 종료가 시작된 뒤에는 새로운 수동 또는 요청 단위 트랜잭션 경계를 거부합니다.
 
-1. 열려 있는 요청 범위 트랜잭션은 `Application shutdown interrupted an open request transaction.` 오류로 abort됩니다.
-2. 활성 ambient session은 transaction callback과 session cleanup이 settle될 때까지 추적됩니다.
-3. 해당 Mongoose 세션은 `abortTransaction()`과 `endSession()` 정리를 끝냅니다.
+1. 열린 요청 단위 트랜잭션은 `Application shutdown interrupted an open request transaction.`으로 abort됩니다.
+2. 활성 ambient session, 원본 request callback, fail-open 직접 실행 transaction callback은 작업이 settle될 때까지 추적됩니다.
+3. 해당 Mongoose 세션은 시작된 callback이 settle된 뒤에만 `abortTransaction()`과 `endSession()` 정리를 끝냅니다.
 4. 설정한 `dispose(connection)` 훅은 활성 요청 트랜잭션과 ambient session scope가 모두 settled된 뒤에만 실행됩니다.
 
-`createMongoosePlatformStatusSnapshot(...)`은 트래픽 처리 중에는 `ready`, 요청 트랜잭션 drain 중에는 `shutting-down`, dispose 훅 완료 뒤에는 `stopped`를 보고합니다. 상태 details에는 `sessionStrategy`, `transactionContext: 'als'`, 활성 요청/session 개수, 리소스 소유권, strict/session 지원 진단이 포함됩니다. 수동 `transaction()`도 요청 범위 트랜잭션과 같은 명시적 세션 계약을 사용하므로, 트랜잭션에 참여해야 하는 Mongoose 모델 작업에는 repository 코드가 `conn.currentSession()`을 전달해야 합니다. 감싼 Mongoose 연결이 `connection.transaction(...)`을 노출하면 fluo는 Mongoose 자체 ambient-session scope를 보존하기 위해 그 API에 transaction boundary를 위임하면서도 같은 session을 `currentSession()`으로 노출합니다. 요청 범위 트랜잭션은 session을 획득하는 동안과 위임된 `connection.transaction(...)` 작업을 시작하는 동안에도 request `AbortSignal`을 관찰하므로, 요청 취소가 사용자 callback 실행 전에 이러한 시작 단계를 중단할 수 있습니다.
+Request cancellation 또는 shutdown이 callback 시작 후 boundary를 abort하면, boundary는 abort 결과를 보존하되 원본 callback이 settle될 때까지 기다린 다음 rollback, session 종료, connection dispose를 진행합니다. 따라서 ALS-backed 작업이 이미 정리된 session이나 connection을 사용하며 계속 실행되지 않습니다.
+
+`MongooseConnection.createPlatformStatusSnapshot()`과 export된 low-level `createMongoosePlatformStatusSnapshot(...)` helper는 serving 중에는 `ready`, 요청 트랜잭션을 drain하는 shutdown 중에는 `shutting-down`, dispose hook 완료 후에는 `stopped`를 보고합니다. status details에는 `sessionStrategy`, `transactionContext: 'als'`, 활성 요청/세션 수, 리소스 소유권, strict/session 지원 진단이 포함됩니다. 수동 `transaction()` 호출과 서비스 `@Transaction()` 메서드는 같은 ambient session을 `conn.model(...)`에 노출합니다. 지원되는 facade 메서드(`create`, `find`, `findOne`, `aggregate`, `bulkWrite`)는 해당 세션을 자동으로 첨부합니다. 자동 세션 주입은 `MongooseConnection.model(...)` wrapper 메서드에만 scope되며, `conn.current()`가 반환하는 raw `connection.model(...)` cache/compile 경로를 교체하거나 변형하지 않습니다. 지원되지 않는 model 메서드, `doc.save()`, 외부 유틸리티에 명시적 세션 배관이 필요할 때는 `conn.currentSession()`을 사용하세요. 래핑된 Mongoose connection이 `connection.transaction(...)`을 제공하면 fluo는 Mongoose 자체 ambient-session scope를 보존하면서 동일한 세션을 `currentSession()`으로 노출하도록 해당 API에 트랜잭션 경계를 위임합니다. 요청 단위 트랜잭션은 세션을 획득하는 동안과 위임된 `connection.transaction(...)` 작업을 시작하는 동안 request `AbortSignal`을 관찰하므로, request cancellation은 사용자 callback이 실행되기 전의 startup phase를 중단할 수 있습니다.
+
 기존 수동 `transaction(...)` boundary 안에서 열린 중첩 `requestTransaction(...)` 호출은 ambient session을 재사용하고 `details.activeRequestTransactions`에 계속 표시되며, 종료 중에 abort되어 바깥 수동 transaction이 `dispose(connection)` 실행 전에 rollback할 수 있습니다.
 
 ## 공통 패턴
 
-### `MongooseConnection`을 통한 연결 접근
+### 서비스 트랜잭션 경계 (@Transaction)
 
-`MongooseConnection` 래퍼는 기본 Mongoose 연결에 대한 접근을 제공합니다.
+`@Transaction()` 데코레이터는 서비스 레이어에서 트랜잭션 경계를 정의하는 권장 방법입니다. 이 데코레이터가 적용된 메서드 내부에서 발생하는 모든 리포지토리 호출은 동일한 MongoDB 세션을 공유합니다.
 
-```typescript
-import { MongooseConnection } from '@fluojs/mongoose';
+```ts
+import { MongooseConnection, Transaction, type MongooseModelFacade } from '@fluojs/mongoose';
+
+type UserDocument = { readonly _id: string; readonly name: string };
+type UserCreateModel = MongooseModelFacade<Promise<readonly [UserDocument]>>;
+type ProfileCreateModel = MongooseModelFacade<Promise<readonly { readonly userId: string }[]>>;
+
+export class UserService {
+  constructor(private readonly repo: UserRepository) {}
+
+  @Transaction()
+  async onboardUser(dto: CreateUserDto) {
+    const [user] = await this.repo.create(dto);
+    await this.repo.initProfile(user._id);
+    return user;
+  }
+}
 
 export class UserRepository {
   constructor(private readonly conn: MongooseConnection) {}
 
-  async findById(id: string) {
-    const User = this.conn.current().model('User');
-    return User.findById(id);
+  async create(data: CreateUserDto) {
+    // @Transaction() 내부에서 conn.model()은 세션 인지형 facade를 반환합니다.
+    // create, find, findOne, aggregate, bulkWrite 등의 작업은
+    // 자동으로 활성 트랜잭션에 참여합니다.
+    return this.conn.model<UserCreateModel>('User').create([data]);
+  }
+
+  async initProfile(userId: string) {
+    return this.conn.model<ProfileCreateModel>('Profile').create([{ userId }]);
   }
 }
 ```
 
-### 수동 트랜잭션과 세션
+`@Transaction()` 메서드 호출은 재진입(reentrant)이 가능합니다. 데코레이터가 적용된 메서드가 다른 데코레이터 적용 메서드를 호출하더라도 하나의 동일한 MongoDB 세션 안에서 실행됩니다. 참고로 v1에서 `doc.save()`는 자동으로 세션을 주입하지 않으므로, 자동 트랜잭션 참여가 필요하다면 지원되는 facade 작업(`model.create()`, `model.find()`, `model.findOne()`, `model.aggregate()`, `model.bulkWrite()`)을 사용하세요.
 
-`conn.transaction()`으로 세션 경계를 만들고, Mongoose 모델 작업에는 세션을 명시적으로 전달합니다.
+### 요청 트랜잭션 인터셉터 호환성
 
-```typescript
-await this.conn.transaction(async () => {
-  const session = this.conn.currentSession();
-  const User = this.conn.current().model('User');
-  
-  // 작업에 세션을 명시적으로 전달
-  await User.create([{ name: 'Ada' }], { session });
-});
+`MongooseTransactionInterceptor`는 기존 request-wide `@UseInterceptors(...)` boundary를 위한 deprecated 1.x 호환성 export로 복원되었습니다. `MongooseModule.forRoot(...)`와 `forRootAsync(...)`가 이 interceptor를 provider 및 export로 제공하며, `MongooseConnection.requestTransaction(...)`에 위임하고 request `AbortSignal`을 전달합니다.
+
+```ts
+import { Controller, Post, UseInterceptors } from '@fluojs/http';
+import { MongooseTransactionInterceptor } from '@fluojs/mongoose';
+
+@Controller('/orders')
+export class OrdersController {
+  @Post('/')
+  @UseInterceptors(MongooseTransactionInterceptor)
+  createOrder() {
+    return this.orders.create();
+  }
+}
 ```
 
-감싼 연결이 `connection.transaction(...)`을 구현하면 `startSession()`이 직접 노출되지 않아도 fluo는 이를 strict transaction boundary로 취급합니다. 그렇지 않고 연결이 `startSession()`을 구현하지 않으면 트랜잭션은 기본적으로 직접 실행으로 fallback합니다. fallback 대신 예외를 던지려면 `strictTransactions: true`를 설정합니다. 이때 오류 메시지는 `Transaction not supported: Mongoose connection does not implement startSession.`입니다.
+새 비즈니스 작업에는 서비스 계층 `@Transaction()`을 우선 사용하세요. 기존 request-wide boundary를 migration하는 동안에만 이 interceptor를 유지하고, request orchestration에서 경계를 명시해야 한다면 `requestTransaction(...)` 직접 호출로 교체하세요.
 
-Fluo는 Mongoose operation option을 다시 쓰지 않습니다. 모델 호출이 명시적인 `{ session }`을 전달하면 그 option은 그대로 유지되며, 생략한 경우 fluo가 session을 자동 부착한다고 가정하면 안 됩니다. 같은 session에서 병렬 작업이나 중첩 transaction 기대치는 보수적으로 유지하세요. 중첩된 `MongooseConnection.transaction(...)` 호출은 같은 session에 두 번째 MongoDB transaction을 여는 대신 활성 boundary를 재사용합니다.
+### 수동 트랜잭션과 currentSession()
 
-### 요청 범위 트랜잭션
+`MongooseConnection`은 활성 MongoDB 세션에 접근하기 위한 `currentSession()`과 루트 연결 handle에 접근하기 위한 `current()` 메서드를 제공합니다. 외부 유틸리티에 세션을 전달하거나 복잡한 수동 처리가 필요한 경우 escape hatch로 사용하세요.
 
-컨트롤러나 메서드에 `MongooseTransactionInterceptor`를 적용하면 전체 요청을 MongoDB 세션으로 감쌉니다.
+```ts
+import { MongooseConnection } from '@fluojs/mongoose';
 
-```typescript
-import { UseInterceptors } from '@fluojs/http';
-import { MongooseTransactionInterceptor } from '@fluojs/mongoose';
+export class AdvancedRepository {
+  constructor(private readonly conn: MongooseConnection) {}
 
-@UseInterceptors(MongooseTransactionInterceptor)
-class UserController {}
+  async customOperation() {
+    const session = this.conn.currentSession();
+    const User = this.conn.current().model('User');
+    
+    // 명시적으로 세션 전달
+    return User.find({ status: 'active' }).session(session || null);
+  }
+}
+```
+
+수동 트랜잭션 블록에는 `conn.transaction()`을 사용하세요:
+
+```ts
+await this.conn.transaction(async () => {
+  const User = this.conn.model('User');
+  await User.create([{ name: 'Ada' }]);
+});
 ```
 
-HTTP interceptor 밖에서 같은 request-aware transaction boundary가 필요하다면 `MongooseConnection.requestTransaction(...)`을 직접 사용할 수 있습니다. 중첩된 service transaction은 활성 session boundary를 재사용하며, 수동 transaction 안에서 열린 중첩 request boundary도 request abort와 shutdown tracking에 참여합니다.
+래핑된 연결이 `connection.transaction(...)`을 구현하고 있다면 fluo는 이를 엄격한 트랜잭션 경계로 취급합니다. 그렇지 않고 `startSession()`이 없는 경우 트랜잭션은 기본값(`strictTransactions: false`)에서 callback 직접 실행으로 fail-open합니다. 이 모드는 local fake나 staged migration에는 유용하지만 rollback 원자성은 제공하지 않습니다. 열린 fail-open 수동 `transaction(...)` callback도 종료 중에 drain되므로 `dispose(connection)`은 해당 callback이 settle된 뒤 실행됩니다. MongoDB transaction 보장이 필요한 production 흐름에서는 `strictTransactions: true`를 설정하세요. 그러면 transaction 지원 누락이 readiness `not-ready`와 helper 예외로 드러납니다.
+
+지원되는 facade 메서드에서 fluo는 기존 Mongoose 작업 옵션을 보존하고 올바른 options 인자에 ambient `{ session }`만 병합합니다. `create(...)`는 Mongoose의 array overload인 `create([docs], options?)`를 통해서만 session을 주입합니다. Positional `create(docA, docB)` 인자는 마지막 문서에 `timestamps` 같은 option-like field가 있어도 그대로 전달되며 자동 session 주입을 받지 않습니다. 트랜잭션 참여가 필요하면 array overload를 사용하세요. 활성 트랜잭션 내부에서 명시적으로 `{ session: null }`을 전달하거나 다른 세션 객체를 사용하면, `findOne(filter, projection, options)`의 세 번째 options 인자를 포함해 의도치 않은 트랜잭션 탈출을 방지하는 세션 충돌 에러를 발생시킵니다. Repository code에서 typed operation result가 필요하면 result-specialized `MongooseModelFacade`를 `model<TModel>(...)` 타입 인자로 전달하세요.
 
 ## 공개 API
 
 - `MongooseModule.forRoot(options)` / `MongooseModule.forRootAsync(options)`
 - `MongooseConnection`
-- `MongooseTransactionInterceptor`
+- `MongooseConnection.createPlatformStatusSnapshot()` — platform observability surface를 위해 health/readiness, resource ownership, 활성 request/session drain 수, strict transaction 지원 진단을 보고합니다.
+- `MongooseConnection.model<TModel>(name, ...args)` — 트랜잭션 밖에서는 callable하고 result-specializable한 `MongooseModelFacade`를 반환하고, 활성 트랜잭션 안에서는 underlying Mongoose connection을 변형하지 않으면서 `create`, `find`, `findOne`, `aggregate`, `bulkWrite`에 세션을 주입하는 버전을 반환합니다.
+- `Transaction`
+- `MongooseTransactionInterceptor` — deprecated request-wide 호환성 interceptor입니다. 새 코드에서는 서비스 `@Transaction()` 또는 명시적 `requestTransaction(...)`을 우선 사용하세요.
 - `MONGOOSE_CONNECTION`, `MONGOOSE_DISPOSE`, `MONGOOSE_OPTIONS`
 - `createMongooseProviders(options)` — 호환성/수동 composition helper입니다. 애플리케이션-facing 등록에서는 module export와 provider visibility가 문서화된 namespace facade와 맞도록 `MongooseModule.forRoot(...)` 또는 `MongooseModule.forRootAsync(...)`를 우선 사용하세요.
 - `createMongoosePlatformStatusSnapshot(...)`
 - sync 및 async 등록 모두에서 `connection`은 실제 object/function handle이어야 하며, 누락된 handle은 모듈 등록 또는 async bootstrap 중 거부됩니다.
+- `Transaction`은 서비스 계층 세션 트랜잭션 경계를 위한 표준 TC39 method decorator입니다. 기본적으로 `this.conn`, 데코레이터가 적용된 인스턴스 자체, 또는 하나의 고유한 중첩 `this.*.conn` collaborator를 resolve합니다. `MongooseConnection`이 다른 필드에 있거나 resolution이 모호하다면 accessor를 전달하세요.
 
 ### 관련 export 타입
 
@@ -133,13 +190,14 @@ HTTP interceptor 밖에서 같은 request-aware transaction boundary가 필요
 - `MongooseAsyncModuleOptions<TConnection>`
 - `MongooseConnectionLike`
 - `MongooseSessionLike`
+- `MongooseModelFacade`
 - `MongooseHandleProvider`
 - `MongoosePlatformStatusSnapshotInput`
 
 ## 관련 패키지
 
 - `@fluojs/runtime`: 애플리케이션 라이프사이클 및 종료 훅을 관리합니다.
-- `@fluojs/http`: 인터셉터 시스템을 제공합니다.
+- `@fluojs/http`: 명시적 `requestTransaction(...)` 경계와 함께 사용할 수 있는 요청 라이프사이클 primitive를 제공합니다.
 - `@fluojs/prisma` / `@fluojs/drizzle`: 대안 데이터베이스 통합 모듈입니다.
 
 ## 예제 소스

package/README.md

@@ -11,6 +11,9 @@ Mongoose integration for fluo with session-aware transaction handling and lifecy
 - [Quick Start](#quick-start)
 - [Lifecycle and Shutdown](#lifecycle-and-shutdown)
 - [Common Patterns](#common-patterns)
+  - [Service Transaction Boundary (@Transaction)](#service-transaction-boundary-transaction)
+  - [Request Transaction Interceptor Compatibility](#request-transaction-interceptor-compatibility)
+  - [Manual Transactions and currentSession()](#manual-transactions-and-currentsession)
 - [Public API](#public-api)
 - [Related Packages](#related-packages)
 - [Example Sources](#example-sources)
@@ -26,7 +29,10 @@ pnpm add mongoose
 
 - when Mongoose should plug into the same DI and application lifecycle as the rest of the app
 - when MongoDB sessions and transactions need one shared wrapper instead of ad hoc session plumbing in every service
-- when request-scoped transactions should be opt-in through an interceptor
+- when request-scoped transactions need explicit `requestTransaction(...)` boundaries
+- when an application already creates and configures its concrete Mongoose connection and wants fluo to observe, not replace, that ownership
+
+The root `@fluojs/mongoose` wrapper uses Node.js `node:async_hooks` for ambient transaction context and supports Node.js 20 or newer, matching the package manifest `engines.node >=20.0.0`. For non-Node runtimes, register raw Mongoose-compatible handles behind application-owned providers instead of importing the root wrapper until a runtime-specific transaction-context adapter is documented.
 
 ## Quick Start
 
@@ -52,71 +58,128 @@ class AppModule {}
 
 ## Lifecycle and Shutdown
 
-`MongooseModule` registers `MongooseConnection` with the fluo application lifecycle. The package does not create or own the raw Mongoose connection for you; pass a `dispose` hook when the application should close that external connection during shutdown.
+`MongooseModule` registers `MongooseConnection` with the fluo application lifecycle. The package does not create or own the raw Mongoose connection for you; pass a concrete Mongoose connection object/function as `connection`, keep connection-string, pool, plugin, and model compilation ownership in the application, and provide a `dispose` hook when the application should close that external connection during shutdown.
 
 Shutdown preserves transaction cleanup order and rejects new manual or request-scoped transaction boundaries once shutdown begins:
 
 1. Open request-scoped transactions are aborted with `Application shutdown interrupted an open request transaction.`
-2. Active ambient sessions are tracked until their transaction callback and session cleanup settle.
-3. Their Mongoose sessions finish `abortTransaction()` and `endSession()` cleanup.
+2. Active ambient sessions, original request callbacks, and fail-open direct-execution transaction callbacks are tracked until their work settles.
+3. Their Mongoose sessions finish `abortTransaction()` and `endSession()` cleanup only after started callbacks settle.
 4. The configured `dispose(connection)` hook runs only after active request transactions and ambient session scopes have settled.
 
-`createMongoosePlatformStatusSnapshot(...)` reports `ready` while serving traffic, `shutting-down` while request transactions are draining, and `stopped` after the dispose hook completes. The status details include `sessionStrategy`, `transactionContext: 'als'`, active request/session counts, resource ownership, and strict/session support diagnostics. Manual `transaction()` calls still use the same explicit-session contract as request-scoped transactions: repository code must pass `conn.currentSession()` into Mongoose model operations that participate in the transaction. If the wrapped Mongoose connection exposes `connection.transaction(...)`, fluo delegates the transaction boundary to that API so Mongoose's own ambient-session scope is preserved while still exposing the same session through `currentSession()`. Request-scoped transactions observe the request `AbortSignal` while acquiring sessions and while starting delegated `connection.transaction(...)` work, so request cancellation can interrupt those startup phases before user callbacks run.
+When request cancellation or shutdown aborts a boundary after its callback has started, the boundary preserves the abort result but waits for the original callback to settle before rolling back, ending the session, or disposing the connection. This prevents ALS-backed work from continuing against an already-cleaned-up session or connection.
+
+`MongooseConnection.createPlatformStatusSnapshot()` and the exported low-level `createMongoosePlatformStatusSnapshot(...)` helper report `ready` while serving traffic, `shutting-down` while request transactions are draining, and `stopped` after the dispose hook completes. The status details include `sessionStrategy`, `transactionContext: 'als'`, active request/session counts, resource ownership, and strict/session support diagnostics. Manual `transaction()` calls and service `@Transaction()` methods expose the same ambient session to `conn.model(...)`; supported facade methods (`create`, `find`, `findOne`, `aggregate`, and `bulkWrite`) automatically attach that session. Automatic session injection is scoped to the `MongooseConnection.model(...)` wrapper method and does not replace or mutate the raw `connection.model(...)` cache/compile path returned by `conn.current()`. Use `conn.currentSession()` for unsupported model methods, `doc.save()`, or external utilities that need explicit session plumbing. If the wrapped Mongoose connection exposes `connection.transaction(...)`, fluo delegates the transaction boundary to that API so Mongoose's own ambient-session scope is preserved while still exposing the same session through `currentSession()`. Request-scoped transactions observe the request `AbortSignal` while acquiring sessions and while starting delegated `connection.transaction(...)` work, so request cancellation can interrupt those startup phases before user callbacks run.
 Nested `requestTransaction(...)` calls opened inside an existing manual `transaction(...)` boundary reuse the ambient session, stay visible in `details.activeRequestTransactions`, and are aborted during shutdown so the outer manual transaction can roll back before `dispose(connection)` runs.
 
 ## Common Patterns
 
-### Access the connection through `MongooseConnection`
+### Service Transaction Boundary (@Transaction)
+
+The `@Transaction()` decorator is the recommended way to define transaction boundaries in your service layer. It ensures that all repository calls made within the decorated method share the same MongoDB session.
 
 ```ts
-import { MongooseConnection } from '@fluojs/mongoose';
+import { MongooseConnection, Transaction, type MongooseModelFacade } from '@fluojs/mongoose';
+
+type UserDocument = { readonly _id: string; readonly name: string };
+type UserCreateModel = MongooseModelFacade<Promise<readonly [UserDocument]>>;
+type ProfileCreateModel = MongooseModelFacade<Promise<readonly { readonly userId: string }[]>>;
+
+export class UserService {
+  constructor(private readonly repo: UserRepository) {}
+
+  @Transaction()
+  async onboardUser(dto: CreateUserDto) {
+    const [user] = await this.repo.create(dto);
+    await this.repo.initProfile(user._id);
+    return user;
+  }
+}
 
 export class UserRepository {
   constructor(private readonly conn: MongooseConnection) {}
 
-  async findById(id: string) {
-    const User = this.conn.current().model('User');
-    return User.findById(id);
+  async create(data: CreateUserDto) {
+    // model() returns a session-aware facade inside @Transaction().
+    // Operations like create, find, findOne, aggregate, and bulkWrite
+    // automatically participate in the ambient transaction.
+    return this.conn.model<UserCreateModel>('User').create([data]);
+  }
+
+  async initProfile(userId: string) {
+    return this.conn.model<ProfileCreateModel>('Profile').create([{ userId }]);
   }
 }
 ```
 
-### Manual transactions still need explicit sessions
+Calls to `@Transaction()` methods are reentrant. If a decorated method calls another decorated method, they share the same underlying MongoDB session. Note that `doc.save()` is not automatically session-aware in v1; use the supported facade operations (`model.create()`, `model.find()`, `model.findOne()`, `model.aggregate()`, or `model.bulkWrite()`) for automatic transaction participation.
+
+### Request Transaction Interceptor Compatibility
+
+`MongooseTransactionInterceptor` is restored as a deprecated 1.x compatibility export for existing request-wide `@UseInterceptors(...)` boundaries. `MongooseModule.forRoot(...)` and `forRootAsync(...)` provide and export it. It delegates to `MongooseConnection.requestTransaction(...)` and forwards the request `AbortSignal`.
 
 ```ts
-await this.conn.transaction(async () => {
-  const session = this.conn.currentSession();
-  const User = this.conn.current().model('User');
+import { Controller, Post, UseInterceptors } from '@fluojs/http';
+import { MongooseTransactionInterceptor } from '@fluojs/mongoose';
 
-  await User.create([{ name: 'Ada' }], { session });
-});
+@Controller('/orders')
+export class OrdersController {
+  @Post('/')
+  @UseInterceptors(MongooseTransactionInterceptor)
+  createOrder() {
+    return this.orders.create();
+  }
+}
 ```
 
-If the wrapped connection implements `connection.transaction(...)`, fluo treats that as the strict transaction boundary even when `startSession()` is not exposed directly. Otherwise, when the connection does not implement `startSession()`, transactions fall back to direct execution by default. Set `strictTransactions: true` to throw `Transaction not supported: Mongoose connection does not implement startSession.` instead of falling back.
+Prefer service-layer `@Transaction()` for new business operations. Keep this interceptor only while migrating existing request-wide boundaries, or replace it with an explicit `requestTransaction(...)` call when request orchestration must make the boundary visible.
 
-Fluo never rewrites Mongoose operation options. If a model call passes an explicit `{ session }`, that option is left intact; if it omits one, repositories should not assume fluo will attach a session for them. Keep same-session parallel work and nested transaction expectations conservative: nested `MongooseConnection.transaction(...)` calls reuse the active boundary rather than opening a second MongoDB transaction on the same session.
+### Manual Transactions and currentSession()
 
-### Request-scoped transactions
+The `MongooseConnection` provides `currentSession()` to access the ambient MongoDB session and `current()` to access the root connection handle. Use these as escape hatches when you need to pass sessions to external utilities or perform advanced manual plumbing.
 
 ```ts
-import { UseInterceptors } from '@fluojs/http';
-import { MongooseTransactionInterceptor } from '@fluojs/mongoose';
+import { MongooseConnection } from '@fluojs/mongoose';
+
+export class AdvancedRepository {
+  constructor(private readonly conn: MongooseConnection) {}
+
+  async customOperation() {
+    const session = this.conn.currentSession();
+    const User = this.conn.current().model('User');
+    
+    // Explicitly passing the session
+    return User.find({ status: 'active' }).session(session || null);
+  }
+}
+```
+
+Use `conn.transaction()` for manual transaction blocks:
 
-@UseInterceptors(MongooseTransactionInterceptor)
-class UserController {}
+```ts
+await this.conn.transaction(async () => {
+  const User = this.conn.model('User');
+  await User.create([{ name: 'Ada' }]);
+});
 ```
 
-Use `MongooseConnection.requestTransaction(...)` directly when you need the same request-aware transaction boundary outside an HTTP interceptor. Nested service transactions reuse the active session boundary, and nested request boundaries opened inside a manual transaction still participate in request abort and shutdown tracking.
+If the wrapped connection implements `connection.transaction(...)`, fluo treats that as the strict transaction boundary. Otherwise, when the connection does not implement `startSession()`, transactions use fail-open direct callback execution by default (`strictTransactions: false`), which is useful for local fakes and staged migrations but provides no rollback atomicity. Open fail-open manual `transaction(...)` callbacks still drain during shutdown before `dispose(connection)` runs. Set `strictTransactions: true` for production flows that require MongoDB transaction guarantees; missing transaction support then makes readiness `not-ready` and causes transaction helpers to throw.
+
+For supported facade methods, fluo preserves existing Mongoose operation options and only merges the ambient `{ session }` into the correct options argument. `create(...)` injects the session only through Mongoose's array overload, `create([docs], options?)`. Positional `create(docA, docB)` arguments are forwarded unchanged—even when the last document contains option-like fields such as `timestamps`—and therefore do not receive automatic session injection. Use the array overload for transaction participation. If a model call passes an explicit `{ session: null }` or a different session object inside an ambient transaction, including the third options argument of `findOne(filter, projection, options)`, fluo throws a session conflict error to prevent accidental transaction escapes. Pass a result-specialized `MongooseModelFacade` as the `model<TModel>(...)` type argument when repository code needs typed operation results.
 
 ## Public API
 
 - `MongooseModule.forRoot(options)` / `MongooseModule.forRootAsync(options)`
 - `MongooseConnection`
-- `MongooseTransactionInterceptor`
+- `MongooseConnection.createPlatformStatusSnapshot()` — reports health/readiness, resource ownership, active request/session drain counts, and strict transaction support diagnostics for platform observability surfaces.
+- `MongooseConnection.model<TModel>(name, ...args)` — returns the callable, result-specializable `MongooseModelFacade` outside transactions or a session-aware version for `create`, `find`, `findOne`, `aggregate`, and `bulkWrite` inside an active transaction without mutating the underlying Mongoose connection.
+- `Transaction`
+- `MongooseTransactionInterceptor` — deprecated request-wide compatibility interceptor; prefer service `@Transaction()` or explicit `requestTransaction(...)` in new code.
 - `MONGOOSE_CONNECTION`, `MONGOOSE_DISPOSE`, `MONGOOSE_OPTIONS`
 - `createMongooseProviders(options)` — compatibility/manual composition helper; prefer `MongooseModule.forRoot(...)` or `MongooseModule.forRootAsync(...)` for application-facing registration so module exports and provider visibility stay aligned.
 - `createMongoosePlatformStatusSnapshot(...)`
 - `connection` must be a concrete object/function handle for both sync and async registration; missing handles are rejected during module registration or async bootstrap.
+- `Transaction` is a standard TC39 method decorator for service-layer session transaction boundaries. It resolves `this.conn`, the decorated instance itself, or one unique nested `this.*.conn` collaborator by default; pass an accessor when the `MongooseConnection` lives under a different field or resolution would be ambiguous.
 
 ### Related exported types
 
@@ -124,13 +187,14 @@ Use `MongooseConnection.requestTransaction(...)` directly when you need the same
 - `MongooseAsyncModuleOptions<TConnection>`
 - `MongooseConnectionLike`
 - `MongooseSessionLike`
+- `MongooseModelFacade`
 - `MongooseHandleProvider`
 - `MongoosePlatformStatusSnapshotInput`
 
 ## Related Packages
 
 - `@fluojs/runtime`: manages startup and shutdown hooks
-- `@fluojs/http`: provides the interceptor chain for request transactions
+- `@fluojs/http`: provides request lifecycle primitives that can be paired with explicit `requestTransaction(...)` boundaries
 - `@fluojs/prisma` and `@fluojs/drizzle`: alternate database integrations with different transaction models
 
 ## Example Sources

package/dist/connection.d.ts

@@ -1,5 +1,5 @@
 import type { OnApplicationShutdown } from '@fluojs/runtime';
-import type { MongooseConnectionLike, MongooseHandleProvider, MongooseSessionLike } from './types.js';
+import type { MongooseConnectionLike, MongooseHandleProvider, MongooseModelFacade, MongooseSessionLike } from './types.js';
 type MongooseRuntimeOptions = {
     strictTransactions: boolean;
 };
@@ -15,6 +15,7 @@ export declare class MongooseConnection<TConnection extends MongooseConnectionLi
     private readonly sessions;
     private readonly activeRequestTransactions;
     private readonly activeSessions;
+    private readonly activeTransactionCallbacks;
     private lifecycleState;
     constructor(connection: TConnection, dispose?: ((connection: TConnection) => Promise<void> | void) | undefined, connectionOptions?: MongooseRuntimeOptions);
     /**
@@ -39,6 +40,15 @@ export declare class MongooseConnection<TConnection extends MongooseConnectionLi
      * @returns The ambient session inside a transaction boundary, or `undefined` outside one.
      */
     currentSession(): MongooseSessionLike | undefined;
+    /**
+     * Returns a model from the root connection, injecting the ambient transaction session into conservative operations.
+     *
+     * @typeParam TModel Consumer-defined facade result contract for the wrapped model.
+     * @param name Model name passed to the underlying Mongoose connection.
+     * @param args Additional model resolver arguments forwarded unchanged.
+     * @returns The real model outside transactions, or a model facade inside an active transaction boundary.
+     */
+    model<TModel extends MongooseModelFacade = MongooseModelFacade>(name: string, ...args: unknown[]): TModel;
     /** Aborts active request transactions, waits for settlement, then runs the optional dispose hook. */
     onApplicationShutdown(): Promise<void>;
     /** Produces the shared persistence status snapshot for platform diagnostics surfaces. */
@@ -73,9 +83,11 @@ export declare class MongooseConnection<TConnection extends MongooseConnectionLi
     private assertTransactionsAvailable;
     private assertRequestTransactionsAvailable;
     private runManualSessionTransaction;
+    private runDirectTransaction;
     private resolveSessionForRequest;
     private runConnectionTransaction;
     private trackActiveSession;
+    private trackActiveTransactionCallback;
     private trackActiveRequestTransaction;
     private untrackActiveRequestTransaction;
     private resolveSession;

package/dist/connection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../src/connection.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAS7D,OAAO,KAAK,EACV,sBAAsB,EACtB,sBAAsB,EACtB,mBAAmB,EACpB,MAAM,YAAY,CAAC;AAuBpB,KAAK,sBAAsB,GAAG;IAC5B,kBAAkB,EAAE,OAAO,CAAC;CAC7B,CAAC;AAmBF;;;;GAIG;AACH,qBACa,kBAAkB,CAAC,WAAW,SAAS,sBAAsB,GAAG,sBAAsB,CACjG,YAAW,sBAAsB,CAAC,WAAW,CAAC,EAAE,qBAAqB;IAQnE,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC;IACzB,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IARpC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgD;IACzE,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAAuC;IACjF,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiC;IAChE,OAAO,CAAC,cAAc,CAAkD;gBAGrD,UAAU,EAAE,WAAW,EACvB,OAAO,CAAC,GAAE,CAAC,UAAU,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,aAAA,EAC3D,iBAAiB,GAAE,sBAAsD;IAG5F;;;;;;;;;OASG;IACH,OAAO,IAAI,WAAW;IAItB;;;;;;;;;OASG;IACH,cAAc,IAAI,mBAAmB,GAAG,SAAS;IAIjD,qGAAqG;IAC/F,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC;IAmB5C,yFAAyF;IACzF,4BAA4B;IAY5B;;;;;;;;;;;;OAYG;IACG,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAoBtD;;;;;;;;;;;OAWG;IACG,kBAAkB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,CAAC,CAAC;IA+CnF,OAAO,CAAC,2BAA2B;IAMnC,OAAO,CAAC,kCAAkC;YAM5B,2BAA2B;YAc3B,wBAAwB;YA4BxB,wBAAwB;IActC,OAAO,CAAC,kBAAkB;IAkB1B,OAAO,CAAC,6BAA6B;IAIrC,OAAO,CAAC,+BAA+B;YAIzB,cAAc;CAW7B"}
+{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../src/connection.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAS7D,OAAO,KAAK,EACV,sBAAsB,EACtB,sBAAsB,EACtB,mBAAmB,EACnB,mBAAmB,EACpB,MAAM,YAAY,CAAC;AAqCpB,KAAK,sBAAsB,GAAG;IAC5B,kBAAkB,EAAE,OAAO,CAAC;CAC7B,CAAC;AAkIF;;;;GAIG;AACH,qBACa,kBAAkB,CAAC,WAAW,SAAS,sBAAsB,GAAG,sBAAsB,CACjG,YAAW,sBAAsB,CAAC,WAAW,CAAC,EAAE,qBAAqB;IASnE,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC;IACzB,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IATpC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgD;IACzE,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAAuC;IACjF,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiC;IAChE,OAAO,CAAC,QAAQ,CAAC,0BAA0B,CAAwC;IACnF,OAAO,CAAC,cAAc,CAAkD;gBAGrD,UAAU,EAAE,WAAW,EACvB,OAAO,CAAC,GAAE,CAAC,UAAU,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,aAAA,EAC3D,iBAAiB,GAAE,sBAAsD;IAG5F;;;;;;;;;OASG;IACH,OAAO,IAAI,WAAW;IAItB;;;;;;;;;OASG;IACH,cAAc,IAAI,mBAAmB,GAAG,SAAS;IAIjD;;;;;;;OAOG;IACH,KAAK,CAAC,MAAM,SAAS,mBAAmB,GAAG,mBAAmB,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,MAAM;IAczG,qGAAqG;IAC/F,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC;IAoB5C,yFAAyF;IACzF,4BAA4B;IAY5B;;;;;;;;;;;;OAYG;IACG,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IA+BtD;;;;;;;;;;;OAWG;IACG,kBAAkB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,CAAC,CAAC;IAwDnF,OAAO,CAAC,2BAA2B;IAMnC,OAAO,CAAC,kCAAkC;YAM5B,2BAA2B;YAc3B,oBAAoB;YAQpB,wBAAwB;YA4BxB,wBAAwB;IActC,OAAO,CAAC,kBAAkB;IA2B1B,OAAO,CAAC,8BAA8B;IAkBtC,OAAO,CAAC,6BAA6B;IAIrC,OAAO,CAAC,+BAA+B;YAIzB,cAAc;CAW7B"}

package/dist/connection.js

@@ -11,6 +11,85 @@ import { createMongoosePlatformStatusSnapshot } from './status.js';
 import { MONGOOSE_CONNECTION, MONGOOSE_DISPOSE, MONGOOSE_OPTIONS } from './tokens.js';
 const TRANSACTIONS_NOT_SUPPORTED_ERROR = 'Transaction not supported: Mongoose connection does not implement startSession.';
 const TRANSACTION_UNAVAILABLE_ERROR = 'Mongoose transactions are unavailable during application shutdown.';
+const MODEL_OPERATIONS_WITH_OPTIONS = new Set(['aggregate', 'bulkWrite', 'create', 'find', 'findOne']);
+const MODEL_OPERATIONS_WITH_PROJECTION = new Set(['find', 'findOne']);
+function isObjectLike(value) {
+  return typeof value === 'object' && value !== null || typeof value === 'function';
+}
+function resolveCreateOptionsIndex(operationArgs) {
+  if (Array.isArray(operationArgs[0])) {
+    return 1;
+  }
+  return undefined;
+}
+function resolveOptionsIndex(operation, operationArgs) {
+  if (operation === 'create') {
+    return resolveCreateOptionsIndex(operationArgs);
+  }
+  if (!MODEL_OPERATIONS_WITH_PROJECTION.has(operation)) {
+    return operationArgs.length > 1 ? 1 : operationArgs.length;
+  }
+  if (operationArgs.length >= 3) {
+    return 2;
+  }
+  if (operationArgs.length <= 1) {
+    return 2;
+  }
+  return operationArgs.length;
+}
+function resolveSessionOptions(opts, ambient) {
+  const options = opts && typeof opts === 'object' ? opts : {};
+  if (options.session === null) {
+    throw new Error('Explicit session: null conflicts with ambient transaction session');
+  }
+  if (options.session !== undefined && options.session !== ambient) {
+    throw new Error('Explicit session conflicts with ambient transaction session');
+  }
+  return {
+    ...options,
+    session: ambient
+  };
+}
+function createAmbientSessionModelFacade(model, ambient) {
+  return new Proxy(model, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (!MODEL_OPERATIONS_WITH_OPTIONS.has(prop) || typeof value !== 'function') {
+        return value;
+      }
+      return (...args) => {
+        const operationArgs = [...args];
+        const optionsIndex = resolveOptionsIndex(prop, operationArgs);
+        if (optionsIndex === undefined) {
+          return value.apply(target, operationArgs);
+        }
+        operationArgs[optionsIndex] = resolveSessionOptions(operationArgs[optionsIndex], ambient);
+        return value.apply(target, operationArgs);
+      };
+    }
+  });
+}
+async function raceWithAbortAndDrainCallback(fn, signal, shouldDrainAfterAbort = () => true) {
+  let callback;
+  try {
+    return await raceWithAbort(() => {
+      callback = Promise.resolve().then(fn);
+      return callback;
+    }, signal);
+  } catch (error) {
+    if (signal.aborted && callback && shouldDrainAfterAbort()) {
+      await callback.then(() => undefined, () => undefined);
+    }
+    throw error;
+  }
+}
+function resolveModelFactory(connection) {
+  if (!isObjectLike(connection)) {
+    return undefined;
+  }
+  const modelConnection = connection;
+  return modelConnection.model;
+}
 async function executeSessionTransaction(session, fn) {
   try {
     await session.startTransaction();
@@ -40,6 +119,7 @@ class MongooseConnection {
   sessions = new AsyncLocalStorage();
   activeRequestTransactions = new Set();
   activeSessions = new Set();
+  activeTransactionCallbacks = new Set();
   lifecycleState = 'ready';
   constructor(connection, dispose, connectionOptions = {
     strictTransactions: false
@@ -74,7 +154,26 @@ class MongooseConnection {
    * @returns The ambient session inside a transaction boundary, or `undefined` outside one.
    */
   currentSession() {
-    return this.sessions.getStore();
+    return this.sessions.getStore()?.session;
+  }
+
+  /**
+   * Returns a model from the root connection, injecting the ambient transaction session into conservative operations.
+   *
+   * @typeParam TModel Consumer-defined facade result contract for the wrapped model.
+   * @param name Model name passed to the underlying Mongoose connection.
+   * @param args Additional model resolver arguments forwarded unchanged.
+   * @returns The real model outside transactions, or a model facade inside an active transaction boundary.
+   */
+
+  model(name, ...args) {
+    const modelFactory = resolveModelFactory(this.connection);
+    if (typeof modelFactory !== 'function') {
+      throw new Error('Mongoose connection does not implement model().');
+    }
+    const model = modelFactory.call(this.connection, name, ...args);
+    const ambient = this.currentSession();
+    return ambient ? createAmbientSessionModelFacade(model, ambient) : model;
   }
 
   /** Aborts active request transactions, waits for settlement, then runs the optional dispose hook. */
@@ -83,7 +182,7 @@ class MongooseConnection {
     for (const transaction of this.activeRequestTransactions) {
       transaction.abort(new Error('Application shutdown interrupted an open request transaction.'));
     }
-    await Promise.allSettled([...Array.from(this.activeRequestTransactions, transaction => transaction.settled), ...Array.from(this.activeSessions, session => session.settled)]);
+    await Promise.allSettled([...Array.from(this.activeRequestTransactions, transaction => transaction.settled), ...Array.from(this.activeSessions, session => session.settled), ...Array.from(this.activeTransactionCallbacks, callback => callback.settled)]);
     if (this.dispose) {
       await this.dispose(this.connection);
     }
@@ -117,18 +216,26 @@ class MongooseConnection {
    * @returns The callback result after the session transaction finishes or the direct-execution fallback completes.
    */
   async transaction(fn) {
+    this.assertTransactionsAvailable();
     const currentSession = this.sessions.getStore();
     if (currentSession) {
       return fn();
     }
-    this.assertTransactionsAvailable();
     if (typeof this.connection.transaction === 'function') {
       return this.runConnectionTransaction(fn);
     }
-    const session = await this.resolveSession();
+    const activeCallback = this.trackActiveTransactionCallback();
+    let session;
+    try {
+      session = await this.resolveSession();
+    } catch (error) {
+      activeCallback.settle();
+      throw error;
+    }
     if (!session) {
-      return fn();
+      return this.runDirectTransaction(fn, activeCallback);
     }
+    activeCallback.settle();
     return this.runManualSessionTransaction(session, fn);
   }
 
@@ -145,16 +252,16 @@ class MongooseConnection {
    * @returns The callback result after the request transaction finishes or the direct-execution fallback completes.
    */
   async requestTransaction(fn, signal) {
-    const currentSession = this.sessions.getStore();
-    if (currentSession) {
+    const currentScope = this.sessions.getStore();
+    if (currentScope) {
       this.assertRequestTransactionsAvailable();
       const abortContext = createRequestAbortContext(signal);
       const active = this.trackActiveRequestTransaction(abortContext.controller);
       try {
-        return await raceWithAbort(fn, abortContext.signal);
+        return await raceWithAbortAndDrainCallback(fn, abortContext.signal);
       } finally {
         abortContext.cleanup();
-        this.untrackActiveRequestTransaction(active);
+        currentScope.activeSession.retainRequestTransaction(active);
       }
     }
     this.assertRequestTransactionsAvailable();
@@ -163,15 +270,20 @@ class MongooseConnection {
     let untrackActiveInFinally = true;
     try {
       if (typeof this.connection.transaction === 'function') {
-        return await raceWithAbort(() => this.runConnectionTransaction(() => raceWithAbort(fn, abortContext.signal)), abortContext.signal);
+        let delegatedCallbackStarted = false;
+        const delegatedTransaction = this.runConnectionTransaction(() => {
+          delegatedCallbackStarted = true;
+          return raceWithAbortAndDrainCallback(fn, abortContext.signal);
+        });
+        return await raceWithAbortAndDrainCallback(() => delegatedTransaction, abortContext.signal, () => delegatedCallbackStarted);
       }
       const resolvedSession = await this.resolveSessionForRequest(abortContext.signal, active, () => {
         untrackActiveInFinally = false;
       });
       if (!resolvedSession) {
-        return await raceWithAbort(fn, abortContext.signal);
+        return await raceWithAbortAndDrainCallback(fn, abortContext.signal);
       }
-      return await this.runManualSessionTransaction(resolvedSession, () => raceWithAbort(fn, abortContext.signal));
+      return await this.runManualSessionTransaction(resolvedSession, () => raceWithAbortAndDrainCallback(fn, abortContext.signal));
     } finally {
       abortContext.cleanup();
       if (untrackActiveInFinally) {
@@ -192,7 +304,10 @@ class MongooseConnection {
   async runManualSessionTransaction(session, fn) {
     const activeSession = this.trackActiveSession();
     try {
-      return await this.sessions.run(session, () => executeSessionTransaction(session, fn));
+      return await this.sessions.run({
+        activeSession,
+        session
+      }, () => executeSessionTransaction(session, fn));
     } finally {
       try {
         await session.endSession();
@@ -201,6 +316,13 @@ class MongooseConnection {
       }
     }
   }
+  async runDirectTransaction(fn, activeCallback) {
+    try {
+      return await fn();
+    } finally {
+      activeCallback.settle();
+    }
+  }
   async resolveSessionForRequest(signal, active, deferActiveSettlement) {
     const sessionPromise = this.resolveSession();
     try {
@@ -224,7 +346,10 @@ class MongooseConnection {
       if (typeof this.connection.transaction !== 'function') {
         throw new Error('Mongoose connection transaction resolver initialization failed.');
       }
-      return await this.connection.transaction(session => this.sessions.run(session, fn));
+      return await this.connection.transaction(session => this.sessions.run({
+        activeSession,
+        session
+      }, fn));
     } finally {
       activeSession.settle();
     }
@@ -236,14 +361,37 @@ class MongooseConnection {
         settle = resolve;
       })
     };
+    const retainedRequestTransactions = new Set();
     this.activeSessions.add(active);
     return {
+      retainRequestTransaction: handle => {
+        retainedRequestTransactions.add(handle);
+      },
       settle: () => {
+        for (const handle of retainedRequestTransactions) {
+          this.untrackActiveRequestTransaction(handle);
+        }
+        retainedRequestTransactions.clear();
         this.activeSessions.delete(active);
         settle();
       }
     };
   }
+  trackActiveTransactionCallback() {
+    let settle;
+    const active = {
+      settled: new Promise(resolve => {
+        settle = resolve;
+      })
+    };
+    this.activeTransactionCallbacks.add(active);
+    return {
+      settle: () => {
+        this.activeTransactionCallbacks.delete(active);
+        settle();
+      }
+    };
+  }
   trackActiveRequestTransaction(controller) {
     return trackActiveRequestTransaction(this.activeRequestTransactions, controller);
   }

package/dist/module.d.ts

@@ -30,7 +30,7 @@ export declare class MongooseModule {
      * Registers Mongoose providers from static options.
      *
      * @param options Mongoose module options with connection handle, optional dispose hook, and strict transaction mode.
-     * @returns A module definition that exports `MongooseConnection` and `MongooseTransactionInterceptor`.
+     * @returns A module definition that exports `MongooseConnection` and its compatibility request interceptor.
      */
     static forRoot<TConnection extends MongooseConnectionLike>(options: MongooseModuleOptions<TConnection>): ModuleType;
     /**

package/dist/module.js

@@ -105,7 +105,7 @@ export class MongooseModule {
    * Registers Mongoose providers from static options.
    *
    * @param options Mongoose module options with connection handle, optional dispose hook, and strict transaction mode.
-   * @returns A module definition that exports `MongooseConnection` and `MongooseTransactionInterceptor`.
+   * @returns A module definition that exports `MongooseConnection` and its compatibility request interceptor.
    */
   static forRoot(options) {
     return buildMongooseModule(options);

package/dist/transaction.d.ts

@@ -1,25 +1,44 @@
-import type { Interceptor, InterceptorContext } from '@fluojs/http';
+import type { CallHandler, Interceptor, InterceptorContext } from '@fluojs/http';
 import { MongooseConnection } from './connection.js';
 import type { MongooseConnectionLike } from './types.js';
+type TransactionConnection = {
+    transaction<T>(fn: () => Promise<T>): Promise<T>;
+};
+type TransactionMethod<THost, TArgs extends unknown[], TResult> = (this: THost, ...args: TArgs) => Promise<TResult>;
 /**
- * HTTP interceptor that wraps each request in a Mongoose request transaction boundary.
+ * Wraps a service method in a `MongooseConnection.transaction(...)` boundary.
  *
  * @remarks
- * Pair this with repository/service code that reads `MongooseConnection.current()` and `currentSession()` so downstream
- * calls share the same request-scoped session.
+ * This is a TC39 standard method decorator. By default it uses `this.conn` when present, the decorated instance
+ * itself when it is transaction-capable, or one unique nested `this.*.conn` collaborator. Pass an accessor when the
+ * connection lives under a different field or more than one nested collaborator exposes a connection; the decorator
+ * does not bind arbitrary transaction-capable properties to avoid selecting the wrong persistence handle.
+ * Nested decorated calls reuse the ambient Mongoose session through `MongooseConnection.transaction(...)`.
+ *
+ * @param accessor Optional connection resolver for the decorated service instance.
+ * @returns A standard method decorator that executes the original method inside a Mongoose transaction.
+ */
+export declare function Transaction<THost>(accessor?: (self: THost) => TransactionConnection): <TArgs extends unknown[], TResult>(value: TransactionMethod<THost, TArgs, TResult>, context: ClassMethodDecoratorContext<THost, TransactionMethod<THost, TArgs, TResult>>) => TransactionMethod<THost, TArgs, TResult>;
+/**
+ * Compatibility HTTP interceptor that opens a Mongoose request transaction around a routed handler.
+ *
+ * @remarks
+ * This deprecated 1.x bridge forwards the request `AbortSignal` to `MongooseConnection.requestTransaction(...)`.
+ * Prefer service-layer `@Transaction()` or an explicit request boundary for new code.
+ *
+ * @deprecated Prefer service-layer `@Transaction()` or explicit `MongooseConnection.requestTransaction(...)`.
  */
 export declare class MongooseTransactionInterceptor implements Interceptor {
     private readonly connection;
     constructor(connection: MongooseConnection<MongooseConnectionLike>);
     /**
-     * Runs the downstream handler inside a Mongoose request transaction boundary.
+     * Runs the downstream handler inside the compatibility request transaction.
      *
-     * @param context Interceptor context that supplies the request abort signal.
+     * @param context Interceptor context containing the request cancellation signal.
      * @param next Downstream handler chain.
-     * @returns The downstream handler result after the request transaction settles.
+     * @returns The downstream result after the request transaction settles.
      */
-    intercept(context: InterceptorContext, next: {
-        handle(): Promise<unknown>;
-    }): Promise<unknown>;
+    intercept(context: InterceptorContext, next: CallHandler): Promise<unknown>;
 }
+export {};
 //# sourceMappingURL=transaction.d.ts.map

package/dist/transaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../src/transaction.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEpE,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAEzD;;;;;;GAMG;AACH,qBACa,8BAA+B,YAAW,WAAW;IACpD,OAAO,CAAC,QAAQ,CAAC,UAAU;gBAAV,UAAU,EAAE,kBAAkB,CAAC,sBAAsB,CAAC;IAEnF;;;;;;OAMG;IACG,SAAS,CAAC,OAAO,EAAE,kBAAkB,EAAE,IAAI,EAAE;QAAE,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,GAAG,OAAO,CAAC,OAAO,CAAC;CAGrG"}
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../src/transaction.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEjF,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAEzD,KAAK,qBAAqB,GAAG;IAC3B,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CAClD,CAAC;AAEF,KAAK,iBAAiB,CAAC,KAAK,EAAE,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO,IAAI,CAChE,IAAI,EAAE,KAAK,EACX,GAAG,IAAI,EAAE,KAAK,KACX,OAAO,CAAC,OAAO,CAAC,CAAC;AA6DtB;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAC/B,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,KAAK,KAAK,qBAAqB,GAChD,CAAC,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO,EAClC,KAAK,EAAE,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAC/C,OAAO,EAAE,2BAA2B,CAAC,KAAK,EAAE,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,KAClF,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,CAW5C;AAED;;;;;;;;GAQG;AACH,qBACa,8BAA+B,YAAW,WAAW;IACpD,OAAO,CAAC,QAAQ,CAAC,UAAU;gBAAV,UAAU,EAAE,kBAAkB,CAAC,sBAAsB,CAAC;IAEnF;;;;;;OAMG;IACG,SAAS,CAAC,OAAO,EAAE,kBAAkB,EAAE,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;CAGlF"}

package/dist/transaction.js

@@ -6,14 +6,82 @@ function _setFunctionName(e, t, n) { "symbol" == typeof t && (t = (t = t.descrip
 function _checkInRHS(e) { if (Object(e) !== e) throw TypeError("right-hand side of 'in' should be an object, got " + (null !== e ? typeof e : "null")); return e; }
 import { Inject } from '@fluojs/core';
 import { MongooseConnection } from './connection.js';
-let _MongooseTransactionI;
+function isTransactionConnection(value) {
+  return (typeof value === 'object' && value !== null || typeof value === 'function') && typeof value.transaction === 'function';
+}
+function collectNestedConnCandidates(self) {
+  if ((typeof self !== 'object' || self === null) && typeof self !== 'function') {
+    return [];
+  }
+  const candidates = new Set();
+  for (const value of Object.values(self)) {
+    if ((typeof value !== 'object' || value === null) && typeof value !== 'function') {
+      continue;
+    }
+    const nestedConn = value.conn;
+    if (isTransactionConnection(nestedConn)) {
+      candidates.add(nestedConn);
+    }
+  }
+  return Array.from(candidates);
+}
+function resolveTransactionConnection(self, accessor) {
+  if (accessor) {
+    const connection = accessor(self);
+    if (isTransactionConnection(connection)) {
+      return connection;
+    }
+    throw new Error('Mongoose @Transaction() accessor did not return a transaction-capable connection.');
+  }
+  const fallbackHost = self;
+  if (isTransactionConnection(fallbackHost.conn)) {
+    return fallbackHost.conn;
+  }
+  if (isTransactionConnection(self)) {
+    return self;
+  }
+  const nestedConnCandidates = collectNestedConnCandidates(self);
+  if (nestedConnCandidates.length === 1) {
+    return nestedConnCandidates[0];
+  }
+  if (nestedConnCandidates.length > 1) {
+    throw new Error('Mongoose @Transaction() found multiple nested this.*.conn candidates; pass an accessor.');
+  }
+  throw new Error('Mongoose @Transaction() could not resolve a transaction-capable connection from this.conn.');
+}
+
+/**
+ * Wraps a service method in a `MongooseConnection.transaction(...)` boundary.
+ *
+ * @remarks
+ * This is a TC39 standard method decorator. By default it uses `this.conn` when present, the decorated instance
+ * itself when it is transaction-capable, or one unique nested `this.*.conn` collaborator. Pass an accessor when the
+ * connection lives under a different field or more than one nested collaborator exposes a connection; the decorator
+ * does not bind arbitrary transaction-capable properties to avoid selecting the wrong persistence handle.
+ * Nested decorated calls reuse the ambient Mongoose session through `MongooseConnection.transaction(...)`.
+ *
+ * @param accessor Optional connection resolver for the decorated service instance.
+ * @returns A standard method decorator that executes the original method inside a Mongoose transaction.
+ */
+export function Transaction(accessor) {
+  return function transactionDecorator(value, _context) {
+    return async function transactionWrappedMethod(...args) {
+      const connection = resolveTransactionConnection(this, accessor);
+      return connection.transaction(() => value.apply(this, args));
+    };
+  };
+}
+
 /**
- * HTTP interceptor that wraps each request in a Mongoose request transaction boundary.
+ * Compatibility HTTP interceptor that opens a Mongoose request transaction around a routed handler.
  *
  * @remarks
- * Pair this with repository/service code that reads `MongooseConnection.current()` and `currentSession()` so downstream
- * calls share the same request-scoped session.
+ * This deprecated 1.x bridge forwards the request `AbortSignal` to `MongooseConnection.requestTransaction(...)`.
+ * Prefer service-layer `@Transaction()` or an explicit request boundary for new code.
+ *
+ * @deprecated Prefer service-layer `@Transaction()` or explicit `MongooseConnection.requestTransaction(...)`.
  */
+let _MongooseTransactionI;
 class MongooseTransactionInterceptor {
   static {
     [_MongooseTransactionI, _initClass] = _applyDecs(this, [Inject(MongooseConnection)], []).c;
@@ -23,14 +91,14 @@ class MongooseTransactionInterceptor {
   }
 
   /**
-   * Runs the downstream handler inside a Mongoose request transaction boundary.
+   * Runs the downstream handler inside the compatibility request transaction.
    *
-   * @param context Interceptor context that supplies the request abort signal.
+   * @param context Interceptor context containing the request cancellation signal.
    * @param next Downstream handler chain.
-   * @returns The downstream handler result after the request transaction settles.
+   * @returns The downstream result after the request transaction settles.
    */
   async intercept(context, next) {
-    return this.connection.requestTransaction(async () => next.handle(), context.requestContext.request.signal);
+    return this.connection.requestTransaction(() => next.handle(), context.requestContext.request.signal);
   }
   static {
     _initClass();

package/dist/types.d.ts

@@ -1,9 +1,10 @@
 import type { MaybePromise } from '@fluojs/core';
 /**
- * Minimal Mongoose connection seam that optionally supports session creation.
+ * Minimal Mongoose connection seam that optionally supports session transaction APIs.
  *
  * @remarks
- * Fluo only requires `startSession()` to expose transaction helpers; plain connection usage still works without it.
+ * Fluo can open transaction helpers through either `connection.transaction(...)` or `startSession()`;
+ * plain connection usage still works without either API.
  */
 export interface MongooseConnectionLike {
     startSession?(): Promise<MongooseSessionLike>;
@@ -18,6 +19,32 @@ export interface MongooseSessionLike {
     abortTransaction(): MaybePromise<void>;
     endSession(): MaybePromise<void>;
 }
+/**
+ * Callable model facade returned by `MongooseConnection.model(...)`.
+ *
+ * @remarks
+ * The listed operations receive the ambient transaction session automatically when called inside a transaction boundary.
+ * Other model properties remain available as `unknown` because fluo does not own application schema or plugin typing.
+ *
+ * @typeParam TCreateResult Result returned by `create(...)`.
+ * @typeParam TFindResult Result returned by `find(...)`.
+ * @typeParam TFindOneResult Result returned by `findOne(...)`.
+ * @typeParam TAggregateResult Result returned by `aggregate(...)`.
+ * @typeParam TBulkWriteResult Result returned by `bulkWrite(...)`.
+ */
+export interface MongooseModelFacade<TCreateResult = unknown, TFindResult = unknown, TFindOneResult = unknown, TAggregateResult = unknown, TBulkWriteResult = unknown> {
+    /** Runs a Mongoose aggregate operation with ambient session options. */
+    aggregate(...args: unknown[]): TAggregateResult;
+    /** Runs a Mongoose bulk-write operation with ambient session options. */
+    bulkWrite(...args: unknown[]): TBulkWriteResult;
+    /** Runs a Mongoose create operation with ambient session options. */
+    create(...args: unknown[]): TCreateResult;
+    /** Runs a Mongoose find operation with ambient session options. */
+    find(...args: unknown[]): TFindResult;
+    /** Runs a Mongoose find-one operation with ambient session options. */
+    findOne(...args: unknown[]): TFindOneResult;
+    readonly [key: PropertyKey]: unknown;
+}
 /**
  * Module options for registering a Mongoose connection and optional shutdown disposal hook.
  *
@@ -31,7 +58,8 @@ export interface MongooseModuleOptions<TConnection extends MongooseConnectionLik
     /** Whether Mongoose providers should be visible globally. Defaults to `false`. */
     global?: boolean;
     /**
-     * Throws when transaction helpers are used against a connection that does not implement `startSession()`.
+     * Throws when transaction helpers are used against a connection that implements neither `connection.transaction(...)` nor
+     * `startSession()`.
      *
      * @remarks
      * Leave this disabled when `transaction()` / `requestTransaction()` should fall back to direct execution.
@@ -48,6 +76,14 @@ export interface MongooseHandleProvider<TConnection extends MongooseConnectionLi
     current(): TConnection;
     /** Returns the ambient Mongoose session for the current async context, when one exists. */
     currentSession(): MongooseSessionLike | undefined;
+    /**
+     * Returns a Mongoose model handle, or a session-aware facade inside an active transaction.
+     *
+     * @param name Model name passed to the underlying Mongoose connection.
+     * @param args Additional model resolver arguments forwarded unchanged.
+     * @returns The root model outside transactions, or a model facade inside an active transaction boundary.
+     */
+    model<TModel extends MongooseModelFacade = MongooseModelFacade>(name: string, ...args: unknown[]): TModel;
     /**
      * Opens a Mongoose session transaction boundary around `fn`.
      *

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACrC,YAAY,CAAC,IAAI,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAC9C,WAAW,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,OAAO,EAAE,mBAAmB,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CAC/E;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,gBAAgB,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;IACvC,iBAAiB,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;IACxC,gBAAgB,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;IACvC,UAAU,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;CAClC;AAED;;;;GAIG;AACH,MAAM,WAAW,qBAAqB,CAAC,WAAW,SAAS,sBAAsB,GAAG,sBAAsB;IACxG,kFAAkF;IAClF,UAAU,EAAE,WAAW,CAAC;IACxB,2FAA2F;IAC3F,OAAO,CAAC,EAAE,CAAC,UAAU,EAAE,WAAW,KAAK,YAAY,CAAC,IAAI,CAAC,CAAC;IAC1D,kFAAkF;IAClF,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED;;;;GAIG;AACH,MAAM,WAAW,sBAAsB,CAAC,WAAW,SAAS,sBAAsB,GAAG,sBAAsB;IACzG,uFAAuF;IACvF,OAAO,IAAI,WAAW,CAAC;IACvB,2FAA2F;IAC3F,cAAc,IAAI,mBAAmB,GAAG,SAAS,CAAC;IAClD;;;;;OAKG;IACH,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IACjD;;;;;;OAMG;IACH,kBAAkB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CAC/E"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD;;;;;;GAMG;AACH,MAAM,WAAW,sBAAsB;IACrC,YAAY,CAAC,IAAI,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAC9C,WAAW,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,OAAO,EAAE,mBAAmB,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CAC/E;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,gBAAgB,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;IACvC,iBAAiB,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;IACxC,gBAAgB,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;IACvC,UAAU,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;CAClC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,mBAAmB,CAClC,aAAa,GAAG,OAAO,EACvB,WAAW,GAAG,OAAO,EACrB,cAAc,GAAG,OAAO,EACxB,gBAAgB,GAAG,OAAO,EAC1B,gBAAgB,GAAG,OAAO;IAE1B,wEAAwE;IACxE,SAAS,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,gBAAgB,CAAC;IAChD,yEAAyE;IACzE,SAAS,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,gBAAgB,CAAC;IAChD,qEAAqE;IACrE,MAAM,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,aAAa,CAAC;IAC1C,mEAAmE;IACnE,IAAI,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,WAAW,CAAC;IACtC,uEAAuE;IACvE,OAAO,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,cAAc,CAAC;IAC5C,QAAQ,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC;CACtC;AAED;;;;GAIG;AACH,MAAM,WAAW,qBAAqB,CAAC,WAAW,SAAS,sBAAsB,GAAG,sBAAsB;IACxG,kFAAkF;IAClF,UAAU,EAAE,WAAW,CAAC;IACxB,2FAA2F;IAC3F,OAAO,CAAC,EAAE,CAAC,UAAU,EAAE,WAAW,KAAK,YAAY,CAAC,IAAI,CAAC,CAAC;IAC1D,kFAAkF;IAClF,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;;;OAMG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED;;;;GAIG;AACH,MAAM,WAAW,sBAAsB,CAAC,WAAW,SAAS,sBAAsB,GAAG,sBAAsB;IACzG,uFAAuF;IACvF,OAAO,IAAI,WAAW,CAAC;IACvB,2FAA2F;IAC3F,cAAc,IAAI,mBAAmB,GAAG,SAAS,CAAC;IAClD;;;;;;OAMG;IACH,KAAK,CAAC,MAAM,SAAS,mBAAmB,GAAG,mBAAmB,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,MAAM,CAAC;IAC1G;;;;;OAKG;IACH,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IACjD;;;;;;OAMG;IACH,kBAAkB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CAC/E"}

package/package.json

@@ -9,7 +9,7 @@
     "transaction",
     "odm"
   ],
-  "version": "1.0.5",
+  "version": "1.1.1",
   "private": false,
   "license": "MIT",
   "repository": {
@@ -36,10 +36,10 @@
     "dist"
   ],
   "dependencies": {
-    "@fluojs/core": "^1.0.3",
-    "@fluojs/http": "^1.1.0",
-    "@fluojs/di": "^1.0.3",
-    "@fluojs/runtime": "^1.1.2"
+    "@fluojs/core": "^1.1.0",
+    "@fluojs/http": "^2.0.1",
+    "@fluojs/di": "^2.0.0",
+    "@fluojs/runtime": "^2.0.1"
   },
   "peerDependencies": {
     "mongoose": ">=7.0.0"