@nest-rn-lens/nest 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 isa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,199 @@
-# Temporary Holding Version
+# @nest-rn-lens/nest
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**See which React Native screen made each request to your NestJS API.**
+
+A NestJS interceptor that records every request your API handles: the app and
+the exact file and line that sent it, the endpoint and the handler that answered,
+the status, and the time it took.
+
+```
+[NestRnLens] mobile (ios) apps/mobile/src/screens/order-details.tsx:23 → GET /orders/:id → OrdersController.findOne 200 4ms
+```
+
+It is the server half of **NestRN Lens**, a toolkit for Turborepo monorepos with
+a NestJS API and a React Native (Expo) app. On its own it gives you readable
+request logs and a typed event for every call. With the NestRN Lens VS Code
+extension, those events become a live traffic panel where you can click any
+request to open the screen that made it or the handler that answered it.
+
+## Install
+
+```bash
+npm install @nest-rn-lens/nest
+# or
+pnpm add @nest-rn-lens/nest
+yarn add @nest-rn-lens/nest
+```
+
+## Requirements
+
+Any NestJS API that serves React Native (or web) clients works. There's nothing
+specific to one project.
+
+| Requirement      | Supported                                       |
+| ---------------- | ----------------------------------------------- |
+| NestJS           | 10, 11 or 12                                    |
+| RxJS             | 7                                               |
+| HTTP platform    | Express (default) or Fastify                    |
+| Module system    | ES modules or CommonJS                          |
+| Node.js          | 18+, or what your NestJS version requires       |
+
+A Turborepo isn't required for the interceptor itself. It's only needed for the
+NestRN Lens VS Code extension, which finds your API and app inside the monorepo.
+
+## Quick start
+
+Import the module once, in your root module:
+
+```ts
+import { Module } from '@nestjs/common';
+import { NestRnLensModule } from '@nest-rn-lens/nest';
+
+@Module({
+  imports: [NestRnLensModule.forRoot({ app: 'api' })],
+})
+export class AppModule {}
+```
+
+That's it. Every request handled by a controller is now logged:
+
+```
+[NestRnLens] unknown (android) → GET /orders → OrdersController.findAll 200 3ms
+```
+
+Requests show `unknown` until the client says who it is. The next section
+explains how.
+
+## Telling the API who's calling
+
+A request on its own doesn't say which app or which screen sent it. The client
+adds that with three headers:
+
+| Header                    | Example                                         | Used for                                          |
+| ------------------------- | ----------------------------------------------- | ------------------------------------------------- |
+| `x-nest-rn-lens-app`      | `mobile`                                        | Which app made the request                        |
+| `x-nest-rn-lens-caller`   | `/repo/apps/mobile/src/screens/orders.tsx:23`   | The file and line that made it                    |
+| `x-nest-rn-lens-trace-id` | `5f0c…`                                         | Linking every hop of one request chain            |
+
+You don't have to write these by hand. The upcoming React Native client,
+`@nest-rn-lens/react-native`, wraps `fetch` and fills them in development,
+working out the calling file from the stack trace.
+
+When a header is missing, the interceptor still reports the request:
+
+- the app is `unknown`
+- the platform is guessed from the `User-Agent` (`okhttp` → Android,
+  `CFNetwork` → iOS, a browser → web)
+- a new trace id is created
+
+The trace id is always sent back in the `x-nest-rn-lens-trace-id` response
+header, so the client or the next service can reuse it.
+
+The header names are exported, so you can use them in your own code:
+
+```ts
+import { NEST_RN_LENS_HEADERS } from '@nest-rn-lens/nest';
+
+fetch(url, { headers: { [NEST_RN_LENS_HEADERS.app]: 'admin-dashboard' } });
+```
+
+## Options
+
+```ts
+NestRnLensModule.forRoot({
+  app: 'api',
+  enabled: true,
+  log: true,
+  onEvent: (event) => {},
+});
+```
+
+| Option    | Type                              | Default                              | Description                                                                                   |
+| --------- | --------------------------------- | ------------------------------------ | --------------------------------------------------------------------------------------------- |
+| `app`     | `string`                          | required                             | Name of this API in logs and in the traffic graph.                                            |
+| `enabled` | `boolean`                         | `true` unless `NODE_ENV=production`  | Turns the interceptor on or off. When off, requests pass through untouched.                   |
+| `log`     | `boolean`                         | `true`                               | Logs a readable line per request, plus the full event as JSON at debug level.                 |
+| `onEvent` | `(event: NestRnLensEvent) => void` | none                                 | Called with every event. Forward traffic to your own tooling, tests or metrics.               |
+
+### The event
+
+```ts
+interface NestRnLensEvent {
+  id: string;
+  traceId: string;
+  timestamp: number; // ms since epoch, when the response was ready
+  durationMs: number;
+  source: {
+    app: string; // "mobile", or "unknown"
+    caller?: string; // "/repo/apps/mobile/src/screens/orders.tsx:23"
+    platform: 'ios' | 'android' | 'web' | 'unknown';
+  };
+  target: {
+    app: string; // your `app` option
+    method: string; // "GET"
+    path: string; // "/orders/42" (no query string)
+    route: string; // "/orders/:id"
+    controller: string; // "OrdersController"
+    handler: string; // "findOne"
+  };
+  status: number; // 200, 201, 404, 500…
+  error?: string; // exception message, when the handler threw
+}
+```
+
+`route` is the route pattern, not the URL, so all calls to one endpoint group
+together. `status` follows Nest's rules: `@HttpCode()` when set, `201` for
+`POST`, the exception's status when a handler throws, and `500` for other errors.
+
+## Safe by design
+
+NestRN Lens is a development tool. It is built so that it can't hurt the API it
+watches:
+
+- **Off in production by default.** Unless you pass `enabled: true`, nothing
+  runs when `NODE_ENV=production`.
+- **Never breaks a request.** If your `onEvent` callback or the logger throws,
+  the error is swallowed and the response goes out as usual.
+- **Doesn't change responses.** The only thing it adds is the trace id header.
+- **HTTP only.** Microservice, WebSocket and GraphQL contexts pass straight
+  through.
+
+## Browsers and CORS
+
+Requests from a web build carry custom headers, so the browser sends a
+preflight request first. Enable CORS in development:
+
+```ts
+const app = await NestFactory.create(AppModule);
+app.enableCors({ exposedHeaders: ['x-nest-rn-lens-trace-id'] });
+```
+
+`exposedHeaders` is only needed if browser code reads the trace id from the
+response. Native React Native apps don't use CORS at all.
+
+## Limitations
+
+- Only requests that reach a controller are reported. A request to a route that
+  doesn't exist gets a 404 from Nest before any interceptor runs.
+- `durationMs` is measured inside Nest, from the interceptor until the handler
+  returns. It doesn't include network time or response serialization.
+
+## NestRN Lens packages
+
+| Package                       | What it does                                                      | Status        |
+| ----------------------------- | ----------------------------------------------------------------- | ------------- |
+| `@nest-rn-lens/nest`          | This interceptor                                                  | Available     |
+| `@nest-rn-lens/react-native`  | `fetch` wrapper that sends the app name and the calling screen    | Coming soon   |
+| NestRN Lens for VS Code       | Live traffic panel with the app running in a phone frame          | Coming soon   |
+
+## Development
+
+```bash
+npm install
+npm test        # builds the tests and runs them on Express and Fastify
+npm run build   # ES module and CommonJS builds in dist/
+```
+
+## License
+
+MIT

package/dist/cjs/constants.d.ts

@@ -0,0 +1,4 @@
+/** Injection token for the resolved module options. */
+export declare const NEST_RN_LENS_OPTIONS: unique symbol;
+/** Logger context. The VS Code extension looks for "[NestRnLens] {json}" lines. */
+export declare const LOGGER_CONTEXT = "NestRnLens";

package/dist/cjs/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOGGER_CONTEXT = exports.NEST_RN_LENS_OPTIONS = void 0;
+/** Injection token for the resolved module options. */
+exports.NEST_RN_LENS_OPTIONS = Symbol('NEST_RN_LENS_OPTIONS');
+/** Logger context. The VS Code extension looks for "[NestRnLens] {json}" lines. */
+exports.LOGGER_CONTEXT = 'NestRnLens';

package/dist/cjs/http.d.ts

@@ -0,0 +1,35 @@
+import type { Platform } from './types.js';
+export interface HttpRequest {
+    method: string;
+    url: string;
+    originalUrl?: string;
+    headers: Record<string, string | string[] | undefined>;
+    /** Express: the matched route. */
+    route?: {
+        path?: unknown;
+    };
+    baseUrl?: string;
+    /** Fastify 4+: the matched route. */
+    routeOptions?: {
+        url?: string;
+    };
+    /** Fastify 3. */
+    routerPath?: string;
+}
+export interface HttpResponse {
+    statusCode: number;
+    /** Express (Node's ServerResponse). */
+    setHeader?(name: string, value: string): unknown;
+    /** Fastify reply. */
+    header?(name: string, value: string): unknown;
+}
+export declare function readHeader(req: HttpRequest, name: string): string | undefined;
+export declare function writeHeader(res: HttpResponse, name: string, value: string): void;
+export declare function requestPath(req: HttpRequest): string;
+/** "/orders/:id" rather than "/orders/42", so one endpoint is one graph edge. */
+export declare function routePattern(req: HttpRequest): string;
+/**
+ * Best guess when the client doesn't say. React Native's fetch uses okhttp on
+ * Android and CFNetwork on iOS; browsers send a Mozilla user agent.
+ */
+export declare function detectPlatform(userAgent?: string): Platform;

package/dist/cjs/http.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readHeader = readHeader;
+exports.writeHeader = writeHeader;
+exports.requestPath = requestPath;
+exports.routePattern = routePattern;
+exports.detectPlatform = detectPlatform;
+function readHeader(req, name) {
+    const value = req.headers[name];
+    return Array.isArray(value) ? value[0] : value;
+}
+function writeHeader(res, name, value) {
+    if (typeof res.header === 'function') {
+        res.header(name, value);
+    }
+    else {
+        res.setHeader?.(name, value);
+    }
+}
+function requestPath(req) {
+    return (req.originalUrl ?? req.url).split('?')[0];
+}
+/** "/orders/:id" rather than "/orders/42", so one endpoint is one graph edge. */
+function routePattern(req) {
+    const expressRoute = req.route?.path;
+    if (typeof expressRoute === 'string') {
+        return `${req.baseUrl ?? ''}${expressRoute}`;
+    }
+    return req.routeOptions?.url ?? req.routerPath ?? requestPath(req);
+}
+/**
+ * Best guess when the client doesn't say. React Native's fetch uses okhttp on
+ * Android and CFNetwork on iOS; browsers send a Mozilla user agent.
+ */
+function detectPlatform(userAgent = '') {
+    if (/okhttp|android/i.test(userAgent)) {
+        return 'android';
+    }
+    if (/CFNetwork|Darwin|iPhone|iPad/i.test(userAgent)) {
+        return 'ios';
+    }
+    if (/Mozilla/i.test(userAgent)) {
+        return 'web';
+    }
+    return 'unknown';
+}

package/dist/cjs/index.d.ts

@@ -0,0 +1,4 @@
+export { NestRnLensModule } from './module.js';
+export { NestRnLensInterceptor } from './interceptor.js';
+export { NEST_RN_LENS_HEADERS } from './types.js';
+export type { NestRnLensEvent, NestRnLensOptions, Platform } from './types.js';

package/dist/cjs/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NEST_RN_LENS_HEADERS = exports.NestRnLensInterceptor = exports.NestRnLensModule = void 0;
+var module_js_1 = require("./module.js");
+Object.defineProperty(exports, "NestRnLensModule", { enumerable: true, get: function () { return module_js_1.NestRnLensModule; } });
+var interceptor_js_1 = require("./interceptor.js");
+Object.defineProperty(exports, "NestRnLensInterceptor", { enumerable: true, get: function () { return interceptor_js_1.NestRnLensInterceptor; } });
+var types_js_1 = require("./types.js");
+Object.defineProperty(exports, "NEST_RN_LENS_HEADERS", { enumerable: true, get: function () { return types_js_1.NEST_RN_LENS_HEADERS; } });

package/dist/cjs/interceptor.d.ts

@@ -0,0 +1,20 @@
+import { type CallHandler, type ExecutionContext, type NestInterceptor } from '@nestjs/common';
+import { type Observable } from 'rxjs';
+import { NestRnLensReporter } from './reporter.js';
+import { type NestRnLensOptions } from './types.js';
+/**
+ * Records every HTTP request handled by a controller: who called it (from the
+ * x-nest-rn-lens-* headers), which handler answered, the status and the time.
+ */
+export declare class NestRnLensInterceptor implements NestInterceptor {
+    private readonly options;
+    private readonly reporter;
+    constructor(options: NestRnLensOptions, reporter: NestRnLensReporter);
+    intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
+    /**
+     * The status Nest is about to send. Depending on the platform it may not be
+     * written to the response yet, so follow Nest's own rules: @HttpCode(),
+     * otherwise 201 for POST and 200 for everything else.
+     */
+    private successStatus;
+}

package/dist/cjs/interceptor.js

@@ -0,0 +1,100 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestRnLensInterceptor = void 0;
+const common_1 = require("@nestjs/common");
+const node_crypto_1 = require("node:crypto");
+const rxjs_1 = require("rxjs");
+const constants_js_1 = require("./constants.js");
+const http_js_1 = require("./http.js");
+const reporter_js_1 = require("./reporter.js");
+const types_js_1 = require("./types.js");
+// Metadata key behind @HttpCode() (HTTP_CODE_METADATA in @nestjs/common/constants,
+// unchanged since Nest 5). Inlined because that subpath resolves differently
+// across Nest versions.
+const HTTP_CODE_METADATA = '__httpCode__';
+/**
+ * Records every HTTP request handled by a controller: who called it (from the
+ * x-nest-rn-lens-* headers), which handler answered, the status and the time.
+ */
+let NestRnLensInterceptor = class NestRnLensInterceptor {
+    options;
+    reporter;
+    constructor(options, reporter) {
+        this.options = options;
+        this.reporter = reporter;
+    }
+    intercept(context, next) {
+        if (!this.options.enabled || context.getType() !== 'http') {
+            return next.handle();
+        }
+        const http = context.switchToHttp();
+        const req = http.getRequest();
+        const res = http.getResponse();
+        const start = performance.now();
+        const traceId = (0, http_js_1.readHeader)(req, types_js_1.NEST_RN_LENS_HEADERS.traceId) ?? (0, node_crypto_1.randomUUID)();
+        // Lets the client, and the next service in the chain, reuse the trace id.
+        (0, http_js_1.writeHeader)(res, types_js_1.NEST_RN_LENS_HEADERS.traceId, traceId);
+        const finish = (status, error) => {
+            const event = {
+                id: (0, node_crypto_1.randomUUID)(),
+                traceId,
+                timestamp: Date.now(),
+                durationMs: Math.round(performance.now() - start),
+                source: {
+                    app: (0, http_js_1.readHeader)(req, types_js_1.NEST_RN_LENS_HEADERS.app) ?? 'unknown',
+                    caller: (0, http_js_1.readHeader)(req, types_js_1.NEST_RN_LENS_HEADERS.caller),
+                    platform: (0, http_js_1.detectPlatform)((0, http_js_1.readHeader)(req, 'user-agent')),
+                },
+                target: {
+                    app: this.options.app,
+                    method: req.method,
+                    path: (0, http_js_1.requestPath)(req),
+                    route: (0, http_js_1.routePattern)(req),
+                    controller: context.getClass().name,
+                    handler: context.getHandler().name,
+                },
+                status,
+                error,
+            };
+            this.reporter.report(event);
+        };
+        return next.handle().pipe((0, rxjs_1.tap)({
+            next: () => finish(this.successStatus(context, req, res)),
+            error: (err) => finish(err instanceof common_1.HttpException ? err.getStatus() : 500, err instanceof Error ? err.message : String(err)),
+        }));
+    }
+    /**
+     * The status Nest is about to send. Depending on the platform it may not be
+     * written to the response yet, so follow Nest's own rules: @HttpCode(),
+     * otherwise 201 for POST and 200 for everything else.
+     */
+    successStatus(context, req, res) {
+        const declared = Reflect.getMetadata(HTTP_CODE_METADATA, context.getHandler());
+        if (declared) {
+            return declared;
+        }
+        // A handler using @Res() may have set its own status.
+        if (res.statusCode && res.statusCode !== 200) {
+            return res.statusCode;
+        }
+        return req.method === 'POST' ? 201 : 200;
+    }
+};
+exports.NestRnLensInterceptor = NestRnLensInterceptor;
+exports.NestRnLensInterceptor = NestRnLensInterceptor = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(constants_js_1.NEST_RN_LENS_OPTIONS)),
+    __metadata("design:paramtypes", [Object, reporter_js_1.NestRnLensReporter])
+], NestRnLensInterceptor);

package/dist/cjs/module.d.ts

@@ -0,0 +1,13 @@
+import { type DynamicModule } from '@nestjs/common';
+import type { NestRnLensOptions } from './types.js';
+export declare class NestRnLensModule {
+    /**
+     * Registers the interceptor for every controller in the app.
+     *
+     * ```ts
+     * @Module({ imports: [NestRnLensModule.forRoot({ app: 'api' })] })
+     * export class AppModule {}
+     * ```
+     */
+    static forRoot(options: NestRnLensOptions): DynamicModule;
+}

package/dist/cjs/module.js

@@ -0,0 +1,44 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var NestRnLensModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestRnLensModule = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const constants_js_1 = require("./constants.js");
+const interceptor_js_1 = require("./interceptor.js");
+const reporter_js_1 = require("./reporter.js");
+let NestRnLensModule = NestRnLensModule_1 = class NestRnLensModule {
+    /**
+     * Registers the interceptor for every controller in the app.
+     *
+     * ```ts
+     * @Module({ imports: [NestRnLensModule.forRoot({ app: 'api' })] })
+     * export class AppModule {}
+     * ```
+     */
+    static forRoot(options) {
+        const resolved = {
+            ...options,
+            enabled: options.enabled ?? process.env.NODE_ENV !== 'production',
+            log: options.log ?? true,
+        };
+        return {
+            module: NestRnLensModule_1,
+            providers: [
+                { provide: constants_js_1.NEST_RN_LENS_OPTIONS, useValue: resolved },
+                reporter_js_1.NestRnLensReporter,
+                { provide: core_1.APP_INTERCEPTOR, useClass: interceptor_js_1.NestRnLensInterceptor },
+            ],
+        };
+    }
+};
+exports.NestRnLensModule = NestRnLensModule;
+exports.NestRnLensModule = NestRnLensModule = NestRnLensModule_1 = __decorate([
+    (0, common_1.Module)({})
+], NestRnLensModule);

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/reporter.d.ts

@@ -0,0 +1,12 @@
+import type { NestRnLensEvent, NestRnLensOptions } from './types.js';
+/** Sends each event to the logger and to the `onEvent` callback. Never throws. */
+export declare class NestRnLensReporter {
+    private readonly options;
+    private readonly logger;
+    private repoRoot?;
+    constructor(options: NestRnLensOptions);
+    report(event: NestRnLensEvent): void;
+    /** "mobile (ios) apps/mobile/src/screens/orders.tsx:17 → GET /orders → OrdersController.findAll 200 4ms" */
+    private describe;
+    private shortPath;
+}

package/dist/cjs/reporter.js

@@ -0,0 +1,78 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestRnLensReporter = void 0;
+const common_1 = require("@nestjs/common");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const constants_js_1 = require("./constants.js");
+/** Sends each event to the logger and to the `onEvent` callback. Never throws. */
+let NestRnLensReporter = class NestRnLensReporter {
+    options;
+    logger = new common_1.Logger(constants_js_1.LOGGER_CONTEXT);
+    repoRoot;
+    constructor(options) {
+        this.options = options;
+    }
+    report(event) {
+        try {
+            this.options.onEvent?.(event);
+        }
+        catch {
+            // A broken callback must not break the request it observes.
+        }
+        if (this.options.log === false) {
+            return;
+        }
+        try {
+            this.logger.log(this.describe(event));
+            this.logger.debug(JSON.stringify(event));
+        }
+        catch {
+            // Same for a broken logger.
+        }
+    }
+    /** "mobile (ios) apps/mobile/src/screens/orders.tsx:17 → GET /orders → OrdersController.findAll 200 4ms" */
+    describe({ source, target, status, durationMs }) {
+        const from = [`${source.app} (${source.platform})`, this.shortPath(source.caller)].filter(Boolean).join(' ');
+        return `${from} → ${target.method} ${target.route} → ${target.controller}.${target.handler} ${status} ${durationMs}ms`;
+    }
+    // Clients send absolute paths (editors need them to open the file); logs are
+    // easier to read relative to the monorepo root.
+    shortPath(file) {
+        if (!file?.startsWith('/')) {
+            return file;
+        }
+        this.repoRoot ??= findRepoRoot(process.cwd());
+        return (0, node_path_1.relative)(this.repoRoot, file);
+    }
+};
+exports.NestRnLensReporter = NestRnLensReporter;
+exports.NestRnLensReporter = NestRnLensReporter = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(constants_js_1.NEST_RN_LENS_OPTIONS)),
+    __metadata("design:paramtypes", [Object])
+], NestRnLensReporter);
+const ROOT_MARKERS = ['turbo.json', 'pnpm-workspace.yaml', '.git'];
+function findRepoRoot(from) {
+    let dir = from;
+    while (!ROOT_MARKERS.some((marker) => (0, node_fs_1.existsSync)((0, node_path_1.join)(dir, marker)))) {
+        const parent = (0, node_path_1.dirname)(dir);
+        if (parent === dir) {
+            return from;
+        }
+        dir = parent;
+    }
+    return dir;
+}

package/dist/cjs/types.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Headers a client sends so the interceptor knows who made the request.
+ * The React Native client (@nest-rn-lens/react-native) fills them in dev.
+ */
+export declare const NEST_RN_LENS_HEADERS: {
+    /** Name of the calling app, e.g. "mobile". */
+    readonly app: "x-nest-rn-lens-app";
+    /** Where in the client the call was made, e.g. "/…/src/screens/OrderList.tsx:42". */
+    readonly caller: "x-nest-rn-lens-caller";
+    /** Same id across every hop of one request chain. Echoed back on the response. */
+    readonly traceId: "x-nest-rn-lens-trace-id";
+};
+export type Platform = 'ios' | 'android' | 'web' | 'unknown';
+/** One request, as seen by the API. */
+export interface NestRnLensEvent {
+    id: string;
+    traceId: string;
+    /** When the response was ready (ms since epoch). */
+    timestamp: number;
+    durationMs: number;
+    source: {
+        /** From the x-nest-rn-lens-app header, or "unknown". */
+        app: string;
+        /** From the x-nest-rn-lens-caller header. */
+        caller?: string;
+        /** Guessed from the User-Agent. */
+        platform: Platform;
+    };
+    target: {
+        /** The `app` option of this API. */
+        app: string;
+        method: string;
+        /** Actual URL path without the query string, e.g. "/orders/42". */
+        path: string;
+        /** Route pattern, e.g. "/orders/:id". Groups requests to the same endpoint. */
+        route: string;
+        controller: string;
+        handler: string;
+    };
+    status: number;
+    /** Message of the exception, when the handler threw. */
+    error?: string;
+}
+export interface NestRnLensOptions {
+    /** Name of this API in the traffic graph, e.g. "api". */
+    app: string;
+    /**
+     * Turns reporting on or off. Defaults to `true` unless NODE_ENV is
+     * "production", so nothing runs in production unless you opt in.
+     */
+    enabled?: boolean;
+    /**
+     * Called with every event. Use it to forward traffic somewhere else.
+     * Errors thrown here are ignored, so they never affect the request.
+     */
+    onEvent?: (event: NestRnLensEvent) => void;
+    /**
+     * Log every event through Nest's Logger (a readable line, plus the JSON at
+     * debug level that the NestRN Lens VS Code extension reads). Defaults to `true`.
+     */
+    log?: boolean;
+}

package/dist/cjs/types.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NEST_RN_LENS_HEADERS = void 0;
+/**
+ * Headers a client sends so the interceptor knows who made the request.
+ * The React Native client (@nest-rn-lens/react-native) fills them in dev.
+ */
+exports.NEST_RN_LENS_HEADERS = {
+    /** Name of the calling app, e.g. "mobile". */
+    app: 'x-nest-rn-lens-app',
+    /** Where in the client the call was made, e.g. "/…/src/screens/OrderList.tsx:42". */
+    caller: 'x-nest-rn-lens-caller',
+    /** Same id across every hop of one request chain. Echoed back on the response. */
+    traceId: 'x-nest-rn-lens-trace-id',
+};

package/dist/esm/constants.d.ts

@@ -0,0 +1,4 @@
+/** Injection token for the resolved module options. */
+export declare const NEST_RN_LENS_OPTIONS: unique symbol;
+/** Logger context. The VS Code extension looks for "[NestRnLens] {json}" lines. */
+export declare const LOGGER_CONTEXT = "NestRnLens";

package/dist/esm/constants.js

@@ -0,0 +1,4 @@
+/** Injection token for the resolved module options. */
+export const NEST_RN_LENS_OPTIONS = Symbol('NEST_RN_LENS_OPTIONS');
+/** Logger context. The VS Code extension looks for "[NestRnLens] {json}" lines. */
+export const LOGGER_CONTEXT = 'NestRnLens';

package/dist/esm/http.d.ts

@@ -0,0 +1,35 @@
+import type { Platform } from './types.js';
+export interface HttpRequest {
+    method: string;
+    url: string;
+    originalUrl?: string;
+    headers: Record<string, string | string[] | undefined>;
+    /** Express: the matched route. */
+    route?: {
+        path?: unknown;
+    };
+    baseUrl?: string;
+    /** Fastify 4+: the matched route. */
+    routeOptions?: {
+        url?: string;
+    };
+    /** Fastify 3. */
+    routerPath?: string;
+}
+export interface HttpResponse {
+    statusCode: number;
+    /** Express (Node's ServerResponse). */
+    setHeader?(name: string, value: string): unknown;
+    /** Fastify reply. */
+    header?(name: string, value: string): unknown;
+}
+export declare function readHeader(req: HttpRequest, name: string): string | undefined;
+export declare function writeHeader(res: HttpResponse, name: string, value: string): void;
+export declare function requestPath(req: HttpRequest): string;
+/** "/orders/:id" rather than "/orders/42", so one endpoint is one graph edge. */
+export declare function routePattern(req: HttpRequest): string;
+/**
+ * Best guess when the client doesn't say. React Native's fetch uses okhttp on
+ * Android and CFNetwork on iOS; browsers send a Mozilla user agent.
+ */
+export declare function detectPlatform(userAgent?: string): Platform;

package/dist/esm/http.js

@@ -0,0 +1,39 @@
+export function readHeader(req, name) {
+    const value = req.headers[name];
+    return Array.isArray(value) ? value[0] : value;
+}
+export function writeHeader(res, name, value) {
+    if (typeof res.header === 'function') {
+        res.header(name, value);
+    }
+    else {
+        res.setHeader?.(name, value);
+    }
+}
+export function requestPath(req) {
+    return (req.originalUrl ?? req.url).split('?')[0];
+}
+/** "/orders/:id" rather than "/orders/42", so one endpoint is one graph edge. */
+export function routePattern(req) {
+    const expressRoute = req.route?.path;
+    if (typeof expressRoute === 'string') {
+        return `${req.baseUrl ?? ''}${expressRoute}`;
+    }
+    return req.routeOptions?.url ?? req.routerPath ?? requestPath(req);
+}
+/**
+ * Best guess when the client doesn't say. React Native's fetch uses okhttp on
+ * Android and CFNetwork on iOS; browsers send a Mozilla user agent.
+ */
+export function detectPlatform(userAgent = '') {
+    if (/okhttp|android/i.test(userAgent)) {
+        return 'android';
+    }
+    if (/CFNetwork|Darwin|iPhone|iPad/i.test(userAgent)) {
+        return 'ios';
+    }
+    if (/Mozilla/i.test(userAgent)) {
+        return 'web';
+    }
+    return 'unknown';
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+export { NestRnLensModule } from './module.js';
+export { NestRnLensInterceptor } from './interceptor.js';
+export { NEST_RN_LENS_HEADERS } from './types.js';
+export type { NestRnLensEvent, NestRnLensOptions, Platform } from './types.js';

package/dist/esm/index.js

@@ -0,0 +1,3 @@
+export { NestRnLensModule } from './module.js';
+export { NestRnLensInterceptor } from './interceptor.js';
+export { NEST_RN_LENS_HEADERS } from './types.js';

package/dist/esm/interceptor.d.ts

@@ -0,0 +1,20 @@
+import { type CallHandler, type ExecutionContext, type NestInterceptor } from '@nestjs/common';
+import { type Observable } from 'rxjs';
+import { NestRnLensReporter } from './reporter.js';
+import { type NestRnLensOptions } from './types.js';
+/**
+ * Records every HTTP request handled by a controller: who called it (from the
+ * x-nest-rn-lens-* headers), which handler answered, the status and the time.
+ */
+export declare class NestRnLensInterceptor implements NestInterceptor {
+    private readonly options;
+    private readonly reporter;
+    constructor(options: NestRnLensOptions, reporter: NestRnLensReporter);
+    intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
+    /**
+     * The status Nest is about to send. Depending on the platform it may not be
+     * written to the response yet, so follow Nest's own rules: @HttpCode(),
+     * otherwise 201 for POST and 200 for everything else.
+     */
+    private successStatus;
+}

package/dist/esm/interceptor.js

@@ -0,0 +1,97 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { HttpException, Inject, Injectable, } from '@nestjs/common';
+import { randomUUID } from 'node:crypto';
+import { tap } from 'rxjs';
+import { NEST_RN_LENS_OPTIONS } from './constants.js';
+import { detectPlatform, readHeader, requestPath, routePattern, writeHeader, } from './http.js';
+import { NestRnLensReporter } from './reporter.js';
+import { NEST_RN_LENS_HEADERS } from './types.js';
+// Metadata key behind @HttpCode() (HTTP_CODE_METADATA in @nestjs/common/constants,
+// unchanged since Nest 5). Inlined because that subpath resolves differently
+// across Nest versions.
+const HTTP_CODE_METADATA = '__httpCode__';
+/**
+ * Records every HTTP request handled by a controller: who called it (from the
+ * x-nest-rn-lens-* headers), which handler answered, the status and the time.
+ */
+let NestRnLensInterceptor = class NestRnLensInterceptor {
+    options;
+    reporter;
+    constructor(options, reporter) {
+        this.options = options;
+        this.reporter = reporter;
+    }
+    intercept(context, next) {
+        if (!this.options.enabled || context.getType() !== 'http') {
+            return next.handle();
+        }
+        const http = context.switchToHttp();
+        const req = http.getRequest();
+        const res = http.getResponse();
+        const start = performance.now();
+        const traceId = readHeader(req, NEST_RN_LENS_HEADERS.traceId) ?? randomUUID();
+        // Lets the client, and the next service in the chain, reuse the trace id.
+        writeHeader(res, NEST_RN_LENS_HEADERS.traceId, traceId);
+        const finish = (status, error) => {
+            const event = {
+                id: randomUUID(),
+                traceId,
+                timestamp: Date.now(),
+                durationMs: Math.round(performance.now() - start),
+                source: {
+                    app: readHeader(req, NEST_RN_LENS_HEADERS.app) ?? 'unknown',
+                    caller: readHeader(req, NEST_RN_LENS_HEADERS.caller),
+                    platform: detectPlatform(readHeader(req, 'user-agent')),
+                },
+                target: {
+                    app: this.options.app,
+                    method: req.method,
+                    path: requestPath(req),
+                    route: routePattern(req),
+                    controller: context.getClass().name,
+                    handler: context.getHandler().name,
+                },
+                status,
+                error,
+            };
+            this.reporter.report(event);
+        };
+        return next.handle().pipe(tap({
+            next: () => finish(this.successStatus(context, req, res)),
+            error: (err) => finish(err instanceof HttpException ? err.getStatus() : 500, err instanceof Error ? err.message : String(err)),
+        }));
+    }
+    /**
+     * The status Nest is about to send. Depending on the platform it may not be
+     * written to the response yet, so follow Nest's own rules: @HttpCode(),
+     * otherwise 201 for POST and 200 for everything else.
+     */
+    successStatus(context, req, res) {
+        const declared = Reflect.getMetadata(HTTP_CODE_METADATA, context.getHandler());
+        if (declared) {
+            return declared;
+        }
+        // A handler using @Res() may have set its own status.
+        if (res.statusCode && res.statusCode !== 200) {
+            return res.statusCode;
+        }
+        return req.method === 'POST' ? 201 : 200;
+    }
+};
+NestRnLensInterceptor = __decorate([
+    Injectable(),
+    __param(0, Inject(NEST_RN_LENS_OPTIONS)),
+    __metadata("design:paramtypes", [Object, NestRnLensReporter])
+], NestRnLensInterceptor);
+export { NestRnLensInterceptor };

package/dist/esm/module.d.ts

@@ -0,0 +1,13 @@
+import { type DynamicModule } from '@nestjs/common';
+import type { NestRnLensOptions } from './types.js';
+export declare class NestRnLensModule {
+    /**
+     * Registers the interceptor for every controller in the app.
+     *
+     * ```ts
+     * @Module({ imports: [NestRnLensModule.forRoot({ app: 'api' })] })
+     * export class AppModule {}
+     * ```
+     */
+    static forRoot(options: NestRnLensOptions): DynamicModule;
+}

package/dist/esm/module.js

@@ -0,0 +1,41 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var NestRnLensModule_1;
+import { Module } from '@nestjs/common';
+import { APP_INTERCEPTOR } from '@nestjs/core';
+import { NEST_RN_LENS_OPTIONS } from './constants.js';
+import { NestRnLensInterceptor } from './interceptor.js';
+import { NestRnLensReporter } from './reporter.js';
+let NestRnLensModule = NestRnLensModule_1 = class NestRnLensModule {
+    /**
+     * Registers the interceptor for every controller in the app.
+     *
+     * ```ts
+     * @Module({ imports: [NestRnLensModule.forRoot({ app: 'api' })] })
+     * export class AppModule {}
+     * ```
+     */
+    static forRoot(options) {
+        const resolved = {
+            ...options,
+            enabled: options.enabled ?? process.env.NODE_ENV !== 'production',
+            log: options.log ?? true,
+        };
+        return {
+            module: NestRnLensModule_1,
+            providers: [
+                { provide: NEST_RN_LENS_OPTIONS, useValue: resolved },
+                NestRnLensReporter,
+                { provide: APP_INTERCEPTOR, useClass: NestRnLensInterceptor },
+            ],
+        };
+    }
+};
+NestRnLensModule = NestRnLensModule_1 = __decorate([
+    Module({})
+], NestRnLensModule);
+export { NestRnLensModule };

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/dist/esm/reporter.d.ts

@@ -0,0 +1,12 @@
+import type { NestRnLensEvent, NestRnLensOptions } from './types.js';
+/** Sends each event to the logger and to the `onEvent` callback. Never throws. */
+export declare class NestRnLensReporter {
+    private readonly options;
+    private readonly logger;
+    private repoRoot?;
+    constructor(options: NestRnLensOptions);
+    report(event: NestRnLensEvent): void;
+    /** "mobile (ios) apps/mobile/src/screens/orders.tsx:17 → GET /orders → OrdersController.findAll 200 4ms" */
+    private describe;
+    private shortPath;
+}

package/dist/esm/reporter.js

@@ -0,0 +1,75 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject, Injectable, Logger } from '@nestjs/common';
+import { existsSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { LOGGER_CONTEXT, NEST_RN_LENS_OPTIONS } from './constants.js';
+/** Sends each event to the logger and to the `onEvent` callback. Never throws. */
+let NestRnLensReporter = class NestRnLensReporter {
+    options;
+    logger = new Logger(LOGGER_CONTEXT);
+    repoRoot;
+    constructor(options) {
+        this.options = options;
+    }
+    report(event) {
+        try {
+            this.options.onEvent?.(event);
+        }
+        catch {
+            // A broken callback must not break the request it observes.
+        }
+        if (this.options.log === false) {
+            return;
+        }
+        try {
+            this.logger.log(this.describe(event));
+            this.logger.debug(JSON.stringify(event));
+        }
+        catch {
+            // Same for a broken logger.
+        }
+    }
+    /** "mobile (ios) apps/mobile/src/screens/orders.tsx:17 → GET /orders → OrdersController.findAll 200 4ms" */
+    describe({ source, target, status, durationMs }) {
+        const from = [`${source.app} (${source.platform})`, this.shortPath(source.caller)].filter(Boolean).join(' ');
+        return `${from} → ${target.method} ${target.route} → ${target.controller}.${target.handler} ${status} ${durationMs}ms`;
+    }
+    // Clients send absolute paths (editors need them to open the file); logs are
+    // easier to read relative to the monorepo root.
+    shortPath(file) {
+        if (!file?.startsWith('/')) {
+            return file;
+        }
+        this.repoRoot ??= findRepoRoot(process.cwd());
+        return relative(this.repoRoot, file);
+    }
+};
+NestRnLensReporter = __decorate([
+    Injectable(),
+    __param(0, Inject(NEST_RN_LENS_OPTIONS)),
+    __metadata("design:paramtypes", [Object])
+], NestRnLensReporter);
+export { NestRnLensReporter };
+const ROOT_MARKERS = ['turbo.json', 'pnpm-workspace.yaml', '.git'];
+function findRepoRoot(from) {
+    let dir = from;
+    while (!ROOT_MARKERS.some((marker) => existsSync(join(dir, marker)))) {
+        const parent = dirname(dir);
+        if (parent === dir) {
+            return from;
+        }
+        dir = parent;
+    }
+    return dir;
+}

package/dist/esm/types.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Headers a client sends so the interceptor knows who made the request.
+ * The React Native client (@nest-rn-lens/react-native) fills them in dev.
+ */
+export declare const NEST_RN_LENS_HEADERS: {
+    /** Name of the calling app, e.g. "mobile". */
+    readonly app: "x-nest-rn-lens-app";
+    /** Where in the client the call was made, e.g. "/…/src/screens/OrderList.tsx:42". */
+    readonly caller: "x-nest-rn-lens-caller";
+    /** Same id across every hop of one request chain. Echoed back on the response. */
+    readonly traceId: "x-nest-rn-lens-trace-id";
+};
+export type Platform = 'ios' | 'android' | 'web' | 'unknown';
+/** One request, as seen by the API. */
+export interface NestRnLensEvent {
+    id: string;
+    traceId: string;
+    /** When the response was ready (ms since epoch). */
+    timestamp: number;
+    durationMs: number;
+    source: {
+        /** From the x-nest-rn-lens-app header, or "unknown". */
+        app: string;
+        /** From the x-nest-rn-lens-caller header. */
+        caller?: string;
+        /** Guessed from the User-Agent. */
+        platform: Platform;
+    };
+    target: {
+        /** The `app` option of this API. */
+        app: string;
+        method: string;
+        /** Actual URL path without the query string, e.g. "/orders/42". */
+        path: string;
+        /** Route pattern, e.g. "/orders/:id". Groups requests to the same endpoint. */
+        route: string;
+        controller: string;
+        handler: string;
+    };
+    status: number;
+    /** Message of the exception, when the handler threw. */
+    error?: string;
+}
+export interface NestRnLensOptions {
+    /** Name of this API in the traffic graph, e.g. "api". */
+    app: string;
+    /**
+     * Turns reporting on or off. Defaults to `true` unless NODE_ENV is
+     * "production", so nothing runs in production unless you opt in.
+     */
+    enabled?: boolean;
+    /**
+     * Called with every event. Use it to forward traffic somewhere else.
+     * Errors thrown here are ignored, so they never affect the request.
+     */
+    onEvent?: (event: NestRnLensEvent) => void;
+    /**
+     * Log every event through Nest's Logger (a readable line, plus the JSON at
+     * debug level that the NestRN Lens VS Code extension reads). Defaults to `true`.
+     */
+    log?: boolean;
+}

package/dist/esm/types.js

@@ -0,0 +1,12 @@
+/**
+ * Headers a client sends so the interceptor knows who made the request.
+ * The React Native client (@nest-rn-lens/react-native) fills them in dev.
+ */
+export const NEST_RN_LENS_HEADERS = {
+    /** Name of the calling app, e.g. "mobile". */
+    app: 'x-nest-rn-lens-app',
+    /** Where in the client the call was made, e.g. "/…/src/screens/OrderList.tsx:42". */
+    caller: 'x-nest-rn-lens-caller',
+    /** Same id across every hop of one request chain. Echoed back on the response. */
+    traceId: 'x-nest-rn-lens-trace-id',
+};

package/package.json

@@ -1,6 +1,69 @@
 {
   "name": "@nest-rn-lens/nest",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "NestJS interceptor that reports every request together with the React Native screen that made it. Part of NestRN Lens.",
+  "keywords": [
+    "nestjs",
+    "nest",
+    "interceptor",
+    "react-native",
+    "expo",
+    "turborepo",
+    "monorepo",
+    "observability",
+    "tracing",
+    "devtools"
+  ],
+  "license": "MIT",
+  "author": "isa",
+  "main": "./dist/cjs/index.js",
+  "types": "./dist/cjs/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "clean": "node -e \"for (const d of ['dist', 'dist-test']) require('fs').rmSync(d, { recursive: true, force: true })\"",
+    "build": "npm run clean && tsc -p tsconfig.build.json && tsc -p tsconfig.esm.json && node scripts/mark-formats.cjs",
+    "typecheck": "tsc --noEmit",
+    "test": "npm run clean && tsc -p tsconfig.test.json && node --test \"dist-test/test/**/*.test.js\"",
+    "prepublishOnly": "npm run typecheck && npm test && npm run build"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^10.0.0 || ^11.0.0 || ^12.0.0",
+    "@nestjs/core": "^10.0.0 || ^11.0.0 || ^12.0.0",
+    "rxjs": "^7.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@nestjs/common": "^12.1.2",
+    "@nestjs/core": "^12.1.2",
+    "@nestjs/platform-express": "^12.1.2",
+    "@nestjs/platform-fastify": "^12.1.2",
+    "@types/node": "^22.20.5",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.2",
+    "typescript": "^6.0.3"
+  },
+  "module": "./dist/esm/index.js"
+}