@dudousxd/nestjs-telescope-inertia-watcher 1.7.0

package/CHANGELOG.md

@@ -0,0 +1,24 @@
+# @dudousxd/nestjs-telescope-inertia-watcher
+
+## 1.7.0
+
+### Minor Changes
+
+- [`b35cc6b`](https://github.com/DavideCarvalho/nestjs-telescope/commit/b35cc6b1508e98f75f2ed78b8d08b93569f47089) - Add `@dudousxd/nestjs-telescope-inertia-watcher`: an `InertiaWatcher` that
+  subscribes to the `nestjs-inertia:render` diagnostics channel and records one
+  `inertia` entry per Inertia render (component, resolved props, deferred/merge
+  classification, partial-reload decision, asset version + 409 version-mismatch,
+  history flags, page size), correlated to the request batch. Adds the
+  `EntryType.Inertia` constant to core. Fully decoupled from `nestjs-inertia` —
+  the channel name and payload shape (`v: 1`) are the only contract; malformed or
+  wrong-version messages are dropped.
+
+### Patch Changes
+
+- [`10c76f1`](https://github.com/DavideCarvalho/nestjs-telescope/commit/10c76f1c0d9c1034e5bffca2d9775cd16e553200) - Inertia panel polish: log on record failure (was silently swallowed) and warn once on
+  an unsupported diagnostic version; collapse `InertiaContent` to
+  `Omit<InertiaRenderDiagnostic, …>` with a destructure-rest copy; make the
+  `isInertiaDiagnostic` guard honest about what it proves; render the Inertia badge in
+  the entries table (parity with the cache badge); data-drive the props rows. Adds a
+  committed cross-repo wire-contract fixture (`inertia-render.v1.json`) so producer
+  drift fails a test.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Davi Carvalho
+
+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

@@ -0,0 +1,46 @@
+# @dudousxd/nestjs-telescope-inertia-watcher
+
+Inertia.js render watcher for [`@dudousxd/nestjs-telescope`](../../README.md).
+Subscribes to the `nestjs-inertia:render` diagnostics channel that
+[`@dudousxd/nestjs-inertia`](https://github.com/DavideCarvalho/nestjs-inertia)
+publishes once per response, and records one `inertia` entry per render
+(rendered component, resolved props, deferred/merge classification, the
+partial-reload decision, asset version + 409 version-mismatch, history flags and
+page size), correlated to the request that produced it.
+
+The bridge is Node's core `node:diagnostics_channel` — telescope **subscribes**,
+inertia **publishes**. The two libraries stay fully decoupled: this package does
+NOT depend on `nestjs-inertia`. The channel name (`nestjs-inertia:render`) and
+the payload shape (`v: 1`) are the only contract; malformed or wrong-version
+messages are dropped, never thrown.
+
+When this watcher isn't installed, inertia's `channel.hasSubscribers` stays
+`false` and it publishes nothing — so the integration costs ~zero when off.
+
+## Install
+
+```sh
+pnpm add @dudousxd/nestjs-telescope-inertia-watcher
+```
+
+## Usage
+
+```ts
+import { TelescopeModule } from '@dudousxd/nestjs-telescope';
+import { InertiaWatcher } from '@dudousxd/nestjs-telescope-inertia-watcher';
+
+TelescopeModule.forRoot({
+  watchers: [new InertiaWatcher()],
+});
+```
+
+On bootstrap the watcher subscribes to the channel (flipping inertia's
+`hasSubscribers` to `true`), so events start flowing. Each captured entry has
+type `inertia` and `InertiaContent`. The heavy `resolvedProps` field is passed
+to the Recorder by reference, so its `redactBounded` clips + masks it with the
+same budget every other entry's content gets (secret keys → `[REDACTED]`,
+oversized trees truncated).
+
+## License
+
+MIT © Davi Carvalho

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { InertiaWatcher } from './inertia.watcher.js';
+export type { InertiaContent, InertiaRenderDiagnostic } from './inertia-content.js';
+export { buildInertiaContent, isInertiaDiagnostic } from './inertia-content.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,YAAY,EAAE,cAAc,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AACpF,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+// packages/inertia-watcher/src/index.ts
+export { InertiaWatcher } from './inertia.watcher.js';
+export { buildInertiaContent, isInertiaDiagnostic } from './inertia-content.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,wCAAwC;AACxC,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/inertia-content.d.ts

@@ -0,0 +1,80 @@
+import { type RecordInput } from '@dudousxd/nestjs-telescope';
+/**
+ * The persisted content of one captured Inertia render: the wire
+ * `InertiaRenderDiagnostic` (below) minus the transport-only `v` and the
+ * always-true `isInertia` discriminator. Defined as an `Omit` so it can never
+ * drift from the wire shape. The heavy `resolvedProps` field is passed THROUGH
+ * to the Recorder by reference so its `redactBounded` clips + masks it with the
+ * standard budget — we do nothing special for size/secrets here.
+ */
+export type InertiaContent = Omit<InertiaRenderDiagnostic, 'v' | 'isInertia'>;
+/**
+ * The wire payload published by `@dudousxd/nestjs-inertia` on the
+ * `nestjs-inertia:render` channel. This shape is the source of truth in
+ * nestjs-inertia's `src/diagnostics.ts` (`InertiaRenderDiagnostic`, spec §1.3);
+ * it is duplicated here STRUCTURALLY (never imported) so the two libraries stay
+ * decoupled. Validate with `isInertiaDiagnostic` before trusting it.
+ */
+export interface InertiaRenderDiagnostic {
+    v: number;
+    component: string;
+    url: string;
+    method: string;
+    isInertia: boolean;
+    isPartial: boolean;
+    partial: {
+        only: string[];
+        except: string[];
+        reset: string[];
+        resetOnce: string[];
+    };
+    props: {
+        sharedKeys: string[];
+        finalKeys: string[];
+        deferred: Record<string, string[]>;
+        merge: string[];
+        deepMerge: string[];
+        matchPropsOn: Record<string, string>;
+        optionalKeys: string[];
+        onceKeys: string[];
+        excludedKeys: string[];
+    };
+    resolvedProps: unknown;
+    assetVersion: string;
+    versionMismatch: boolean;
+    clientVersion: string | null;
+    encryptHistory: boolean;
+    clearHistory: boolean;
+    statusCode: number;
+    pageBytes: number;
+    ssr: boolean;
+}
+/**
+ * True when a message is shaped like our diagnostic — it carries a numeric `v`
+ * and the load-bearing render fields — REGARDLESS of version. Lets the watcher
+ * tell "Inertia-shaped but unsupported `v`" (warn once) apart from ordinary
+ * non-Inertia channel noise (drop silently). Never throws.
+ */
+export declare function isInertiaShaped(msg: unknown): msg is {
+    v: number;
+} & Partial<InertiaRenderDiagnostic>;
+/**
+ * Defensive structural validation of an untrusted channel message: Inertia-shaped
+ * AND a supported `v === 1`. The watcher records only these (fail-safe across
+ * producer version bumps). Narrowed return type — this proves the version and the
+ * load-bearing fields it actually checks, not the whole payload; the UI re-reads
+ * every other field defensively. Never throws.
+ */
+export declare function isInertiaDiagnostic(msg: unknown): msg is {
+    v: 1;
+} & Partial<InertiaRenderDiagnostic>;
+/**
+ * Map a validated diagnostic to a `RecordInput`. `familyHash` groups all renders
+ * of a component (`inertia:<component>`), mirroring `event:<name>` / `redis:<CMD>`.
+ * `durationMs` is null — render time belongs to the sibling `request` entry. The
+ * content is the wire payload minus `v`/`isInertia` via destructure-rest, so the
+ * heavy `resolvedProps` is carried BY REFERENCE (no clone/stringify) for the
+ * Recorder's `redactBounded` to traverse, clip, and mask.
+ */
+export declare function buildInertiaContent(d: InertiaRenderDiagnostic): RecordInput<InertiaContent>;
+//# sourceMappingURL=inertia-content.d.ts.map

package/dist/inertia-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inertia-content.d.ts","sourceRoot":"","sources":["../src/inertia-content.ts"],"names":[],"mappings":"AACA,OAAO,EAAa,KAAK,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAEzE;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,GAAG,IAAI,CAAC,uBAAuB,EAAE,GAAG,GAAG,WAAW,CAAC,CAAC;AAE9E;;;;;;GAMG;AACH,MAAM,WAAW,uBAAuB;IACtC,CAAC,EAAE,MAAM,CAAC;IACV,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,SAAS,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IACpF,KAAK,EAAE;QACL,UAAU,EAAE,MAAM,EAAE,CAAC;QACrB,SAAS,EAAE,MAAM,EAAE,CAAC;QACpB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;QACnC,KAAK,EAAE,MAAM,EAAE,CAAC;QAChB,SAAS,EAAE,MAAM,EAAE,CAAC;QACpB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACrC,YAAY,EAAE,MAAM,EAAE,CAAC;QACvB,QAAQ,EAAE,MAAM,EAAE,CAAC;QACnB,YAAY,EAAE,MAAM,EAAE,CAAC;KACxB,CAAC;IACF,aAAa,EAAE,OAAO,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,OAAO,CAAC;IACzB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,cAAc,EAAE,OAAO,CAAC;IACxB,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,OAAO,CAAC;CACd;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,OAAO,GACX,GAAG,IAAI;IAAE,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAazD;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,OAAO,GACX,GAAG,IAAI;IAAE,CAAC,EAAE,CAAC,CAAA;CAAE,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAEpD;AAYD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,uBAAuB,GAAG,WAAW,CAAC,cAAc,CAAC,CAS3F"}

package/dist/inertia-content.js

@@ -0,0 +1,63 @@
+// packages/inertia-watcher/src/inertia-content.ts
+import { EntryType } from '@dudousxd/nestjs-telescope';
+/**
+ * True when a message is shaped like our diagnostic — it carries a numeric `v`
+ * and the load-bearing render fields — REGARDLESS of version. Lets the watcher
+ * tell "Inertia-shaped but unsupported `v`" (warn once) apart from ordinary
+ * non-Inertia channel noise (drop silently). Never throws.
+ */
+export function isInertiaShaped(msg) {
+    if (typeof msg !== 'object' || msg === null)
+        return false;
+    const m = msg;
+    return (typeof m.v === 'number' &&
+        typeof m.component === 'string' &&
+        typeof m.url === 'string' &&
+        typeof m.method === 'string' &&
+        typeof m.props === 'object' &&
+        m.props !== null &&
+        typeof m.partial === 'object' &&
+        m.partial !== null);
+}
+/**
+ * Defensive structural validation of an untrusted channel message: Inertia-shaped
+ * AND a supported `v === 1`. The watcher records only these (fail-safe across
+ * producer version bumps). Narrowed return type — this proves the version and the
+ * load-bearing fields it actually checks, not the whole payload; the UI re-reads
+ * every other field defensively. Never throws.
+ */
+export function isInertiaDiagnostic(msg) {
+    return isInertiaShaped(msg) && msg.v === 1;
+}
+/** Build the tag list for one render: base tags + partial/mismatch/deferred/merge flags. */
+function buildTags(d) {
+    const tags = ['inertia', `inertia:component:${d.component}`];
+    if (d.isPartial)
+        tags.push('inertia:partial');
+    if (d.versionMismatch)
+        tags.push('inertia:version-mismatch');
+    if (Object.keys(d.props.deferred ?? {}).length)
+        tags.push('inertia:deferred');
+    if ((d.props.merge?.length ?? 0) || (d.props.deepMerge?.length ?? 0))
+        tags.push('inertia:merge');
+    return tags;
+}
+/**
+ * Map a validated diagnostic to a `RecordInput`. `familyHash` groups all renders
+ * of a component (`inertia:<component>`), mirroring `event:<name>` / `redis:<CMD>`.
+ * `durationMs` is null — render time belongs to the sibling `request` entry. The
+ * content is the wire payload minus `v`/`isInertia` via destructure-rest, so the
+ * heavy `resolvedProps` is carried BY REFERENCE (no clone/stringify) for the
+ * Recorder's `redactBounded` to traverse, clip, and mask.
+ */
+export function buildInertiaContent(d) {
+    const { v, isInertia, ...content } = d;
+    return {
+        type: EntryType.Inertia,
+        familyHash: `inertia:${d.component}`,
+        durationMs: null,
+        tags: buildTags(d),
+        content,
+    };
+}
+//# sourceMappingURL=inertia-content.js.map

package/dist/inertia-content.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inertia-content.js","sourceRoot":"","sources":["../src/inertia-content.ts"],"names":[],"mappings":"AAAA,kDAAkD;AAClD,OAAO,EAAE,SAAS,EAAoB,MAAM,4BAA4B,CAAC;AAiDzE;;;;;GAKG;AACH,MAAM,UAAU,eAAe,CAC7B,GAAY;IAEZ,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAC1D,MAAM,CAAC,GAAG,GAA8B,CAAC;IACzC,OAAO,CACL,OAAO,CAAC,CAAC,CAAC,KAAK,QAAQ;QACvB,OAAO,CAAC,CAAC,SAAS,KAAK,QAAQ;QAC/B,OAAO,CAAC,CAAC,GAAG,KAAK,QAAQ;QACzB,OAAO,CAAC,CAAC,MAAM,KAAK,QAAQ;QAC5B,OAAO,CAAC,CAAC,KAAK,KAAK,QAAQ;QAC3B,CAAC,CAAC,KAAK,KAAK,IAAI;QAChB,OAAO,CAAC,CAAC,OAAO,KAAK,QAAQ;QAC7B,CAAC,CAAC,OAAO,KAAK,IAAI,CACnB,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,mBAAmB,CACjC,GAAY;IAEZ,OAAO,eAAe,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC;AAC7C,CAAC;AAED,4FAA4F;AAC5F,SAAS,SAAS,CAAC,CAA0B;IAC3C,MAAM,IAAI,GAAG,CAAC,SAAS,EAAE,qBAAqB,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC;IAC7D,IAAI,CAAC,CAAC,SAAS;QAAE,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;IAC9C,IAAI,CAAC,CAAC,eAAe;QAAE,IAAI,CAAC,IAAI,CAAC,0BAA0B,CAAC,CAAC;IAC7D,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,MAAM;QAAE,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;IAC9E,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,EAAE,MAAM,IAAI,CAAC,CAAC;QAAE,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;IACjG,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,mBAAmB,CAAC,CAA0B;IAC5D,MAAM,EAAE,CAAC,EAAE,SAAS,EAAE,GAAG,OAAO,EAAE,GAAG,CAAC,CAAC;IACvC,OAAO;QACL,IAAI,EAAE,SAAS,CAAC,OAAO;QACvB,UAAU,EAAE,WAAW,CAAC,CAAC,SAAS,EAAE;QACpC,UAAU,EAAE,IAAI;QAChB,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC;QAClB,OAAO;KACR,CAAC;AACJ,CAAC"}

package/dist/inertia.watcher.d.ts

@@ -0,0 +1,30 @@
+import { type Watcher, type WatcherContext } from '@dudousxd/nestjs-telescope';
+/**
+ * Records every Inertia response published on the `nestjs-inertia:render`
+ * diagnostics channel as one `inertia` entry, correlated to the active
+ * request/job batch.
+ *
+ * ## How it works
+ * On `register` the watcher subscribes a listener to the channel. `inertia`
+ * publishes synchronously inside `InertiaService.render()`, so the listener runs
+ * on the same call stack / async context as the render — `ctx.record(...)` lands
+ * in the request's ALS batch (no batch is opened here, no request-id plumbing).
+ * Subscribing also flips inertia's `channel.hasSubscribers` to `true`, which is
+ * what makes the producer start building + publishing payloads at all.
+ *
+ * ## Resilience
+ * Each message is structurally validated (`isInertiaDiagnostic`, `v === 1`);
+ * malformed or wrong-version payloads are dropped. All recording is wrapped so a
+ * telescope error can never break a render. Registration is idempotent.
+ */
+export declare class InertiaWatcher implements Watcher {
+    readonly type: "inertia";
+    private registered;
+    private onMessage;
+    register(ctx: WatcherContext): void;
+    /** Unsubscribe the listener. Safe to call when never registered. */
+    cleanup(): void;
+    /** Validate + record, swallowing any failure so a render can never break. */
+    private safeRecord;
+}
+//# sourceMappingURL=inertia.watcher.d.ts.map

package/dist/inertia.watcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inertia.watcher.d.ts","sourceRoot":"","sources":["../src/inertia.watcher.ts"],"names":[],"mappings":"AAEA,OAAO,EAAa,KAAK,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAiB1F;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,cAAe,YAAW,OAAO;IAC5C,QAAQ,CAAC,IAAI,YAAqB;IAClC,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,SAAS,CAAyC;IAE1D,QAAQ,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI;IASnC,oEAAoE;IACpE,OAAO,IAAI,IAAI;IAQf,6EAA6E;IAC7E,OAAO,CAAC,UAAU;CAmBnB"}

package/dist/inertia.watcher.js

@@ -0,0 +1,75 @@
+// packages/inertia-watcher/src/inertia.watcher.ts
+import diagnostics_channel from 'node:diagnostics_channel';
+import { EntryType } from '@dudousxd/nestjs-telescope';
+import { buildInertiaContent, isInertiaDiagnostic, isInertiaShaped } from './inertia-content.js';
+/**
+ * The channel name is the cross-repo contract with `@dudousxd/nestjs-inertia`
+ * (exported there as `INERTIA_DIAG_CHANNEL`). Hardcoded here — telescope must NOT
+ * import inertia at runtime. Keep this string byte-identical on both sides.
+ */
+const INERTIA_CHANNEL = 'nestjs-inertia:render';
+/**
+ * One-time guard so an unsupported producer version (`v !== 1`) is surfaced once
+ * per process instead of every render — distinct from ordinary non-Inertia noise,
+ * which stays silent.
+ */
+let warnedUnsupportedVersion = false;
+/**
+ * Records every Inertia response published on the `nestjs-inertia:render`
+ * diagnostics channel as one `inertia` entry, correlated to the active
+ * request/job batch.
+ *
+ * ## How it works
+ * On `register` the watcher subscribes a listener to the channel. `inertia`
+ * publishes synchronously inside `InertiaService.render()`, so the listener runs
+ * on the same call stack / async context as the render — `ctx.record(...)` lands
+ * in the request's ALS batch (no batch is opened here, no request-id plumbing).
+ * Subscribing also flips inertia's `channel.hasSubscribers` to `true`, which is
+ * what makes the producer start building + publishing payloads at all.
+ *
+ * ## Resilience
+ * Each message is structurally validated (`isInertiaDiagnostic`, `v === 1`);
+ * malformed or wrong-version payloads are dropped. All recording is wrapped so a
+ * telescope error can never break a render. Registration is idempotent.
+ */
+export class InertiaWatcher {
+    type = EntryType.Inertia;
+    registered = false;
+    onMessage = null;
+    register(ctx) {
+        if (this.registered)
+            return;
+        this.registered = true;
+        const channel = diagnostics_channel.channel(INERTIA_CHANNEL);
+        this.onMessage = (msg) => this.safeRecord(ctx, msg);
+        channel.subscribe(this.onMessage);
+    }
+    /** Unsubscribe the listener. Safe to call when never registered. */
+    cleanup() {
+        if (this.onMessage) {
+            diagnostics_channel.channel(INERTIA_CHANNEL).unsubscribe(this.onMessage);
+            this.onMessage = null;
+        }
+        this.registered = false;
+    }
+    /** Validate + record, swallowing any failure so a render can never break. */
+    safeRecord(ctx, msg) {
+        try {
+            if (!isInertiaDiagnostic(msg)) {
+                // Inertia-shaped but an unsupported producer version: warn once so the
+                // drift is visible. Genuine non-Inertia messages fall through silently.
+                if (!warnedUnsupportedVersion && isInertiaShaped(msg)) {
+                    warnedUnsupportedVersion = true;
+                    console.warn(`InertiaWatcher: dropping unsupported diagnostic version v=${msg.v} (expected 1) — upgrade @dudousxd/nestjs-telescope to match @dudousxd/nestjs-inertia`);
+                }
+                return;
+            }
+            ctx.record(buildInertiaContent(msg));
+        }
+        catch (err) {
+            // NOT rethrown — telescope must never break an Inertia render.
+            console.error('InertiaWatcher: failed to record inertia render:', err);
+        }
+    }
+}
+//# sourceMappingURL=inertia.watcher.js.map

package/dist/inertia.watcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inertia.watcher.js","sourceRoot":"","sources":["../src/inertia.watcher.ts"],"names":[],"mappings":"AAAA,kDAAkD;AAClD,OAAO,mBAAmB,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,SAAS,EAAqC,MAAM,4BAA4B,CAAC;AAC1F,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEjG;;;;GAIG;AACH,MAAM,eAAe,GAAG,uBAAuB,CAAC;AAEhD;;;;GAIG;AACH,IAAI,wBAAwB,GAAG,KAAK,CAAC;AAErC;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,OAAO,cAAc;IAChB,IAAI,GAAG,SAAS,CAAC,OAAO,CAAC;IAC1B,UAAU,GAAG,KAAK,CAAC;IACnB,SAAS,GAAoC,IAAI,CAAC;IAE1D,QAAQ,CAAC,GAAmB;QAC1B,IAAI,IAAI,CAAC,UAAU;YAAE,OAAO;QAC5B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QAEvB,MAAM,OAAO,GAAG,mBAAmB,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;QAC7D,IAAI,CAAC,SAAS,GAAG,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;QACpD,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IACpC,CAAC;IAED,oEAAoE;IACpE,OAAO;QACL,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACnB,mBAAmB,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YACzE,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACxB,CAAC;QACD,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;IAC1B,CAAC;IAED,6EAA6E;IACrE,UAAU,CAAC,GAAmB,EAAE,GAAY;QAClD,IAAI,CAAC;YACH,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,EAAE,CAAC;gBAC9B,uEAAuE;gBACvE,wEAAwE;gBACxE,IAAI,CAAC,wBAAwB,IAAI,eAAe,CAAC,GAAG,CAAC,EAAE,CAAC;oBACtD,wBAAwB,GAAG,IAAI,CAAC;oBAChC,OAAO,CAAC,IAAI,CACV,6DAA6D,GAAG,CAAC,CAAC,sFAAsF,CACzJ,CAAC;gBACJ,CAAC;gBACD,OAAO;YACT,CAAC;YACD,GAAG,CAAC,MAAM,CAAC,mBAAmB,CAAC,GAAgD,CAAC,CAAC,CAAC;QACpF,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,+DAA+D;YAC/D,OAAO,CAAC,KAAK,CAAC,kDAAkD,EAAE,GAAG,CAAC,CAAC;QACzE,CAAC;IACH,CAAC;CACF"}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@dudousxd/nestjs-telescope-inertia-watcher",
+  "version": "1.7.0",
+  "description": "Inertia.js render watcher for @dudousxd/nestjs-telescope.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DavideCarvalho/nestjs-telescope.git",
+    "directory": "packages/inertia-watcher"
+  },
+  "author": "Davi Carvalho <davi@goflip.ai>",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "peerDependencies": {
+    "@dudousxd/nestjs-telescope": "^1.7.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "reflect-metadata": "^0.2.2",
+    "typescript": "^5.4.0",
+    "vitest": "^3.0.0",
+    "@dudousxd/nestjs-telescope": "1.7.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "nestjs",
+    "telescope",
+    "inertia",
+    "inertia.js",
+    "observability"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run --passWithNoTests",
+    "test:watch": "vitest",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}