@adonis-agora/telescope 0.4.0 → 0.5.1

package/dist/src/client_errors/index.js

@@ -0,0 +1,5 @@
+export { DEFAULT_CLIENT_ERRORS_PATH, DEFAULT_MAX_BODY_BYTES, DEFAULT_RATE_LIMIT_PER_MINUTE, resolveClientErrors, } from './config.js';
+export { ClientErrorIngestor, storeRecorder, } from './ingestor.js';
+export { ClientErrorRateLimiter, DEFAULT_MAX_TRACKED_IPS } from './rate_limiter.js';
+export { userIdentityTag, validateClientErrorBody, } from './validation.js';
+//# sourceMappingURL=index.js.map

package/dist/src/client_errors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/client_errors/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,0BAA0B,EAC1B,sBAAsB,EACtB,6BAA6B,EAC7B,mBAAmB,GAEpB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,mBAAmB,EAKnB,aAAa,GACd,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AACpF,OAAO,EAGL,eAAe,EACf,uBAAuB,GACxB,MAAM,iBAAiB,CAAC"}

package/dist/src/client_errors/ingestor.d.ts

@@ -0,0 +1,87 @@
+import { type RecordInput } from '../entry.js';
+import type { TelescopeStore } from '../store.js';
+import type { ResolvedClientErrorsConfig } from './config.js';
+import { type ClientExceptionContent } from './validation.js';
+/**
+ * The minimal HTTP surface the ingestor reads/writes, kept deliberately
+ * framework-light so the handler is unit-testable with a plain object (no
+ * running AdonisJS server). An Adonis `HttpContext` satisfies this structurally
+ * — `request.body()`, `request.header()`, `request.ip()`, and a `response` that
+ * can set a status and send a body — so the provider passes the real `ctx`
+ * straight through.
+ */
+export interface ClientErrorRequest {
+    /** The parsed request body (Adonis `request.body()`). */
+    body(): unknown;
+    /** A single request header by (case-insensitive) name, or `undefined`. */
+    header(name: string): string | undefined;
+    /** The resolving client IP (Adonis `request.ip()`, which honours trust-proxy). */
+    ip(): string | undefined;
+}
+/** The slice of an outbound response the ingestor writes. */
+export interface ClientErrorResponse {
+    /** Set the HTTP status code; returns `this` for chaining (Adonis-compatible). */
+    status(code: number): ClientErrorResponse;
+    /** Send a body (object → JSON, string → as-is). Terminal. */
+    send(body: unknown): unknown;
+}
+/** A framework-light HTTP context: just the request + response slices above. */
+export interface ClientErrorHttpContext {
+    request: ClientErrorRequest;
+    response: ClientErrorResponse;
+}
+/** Injectable seams so the ingestor is testable without the global runtime. */
+export interface ClientErrorIngestorDeps {
+    config: ResolvedClientErrorsConfig;
+    /**
+     * Fire-and-forget recorder. Wired by the provider to
+     * `store.record(input)` with rejections swallowed. Injected (rather than the
+     * store) so a test can assert exactly what would be recorded.
+     */
+    record: (input: RecordInput<ClientExceptionContent>) => void;
+    /** Overload-shed seam. Defaults to the global runtime `paused` flag. */
+    isPaused?: () => boolean;
+    /** Wall-clock seam (ms) for the rate limiter. Defaults to `Date.now`. */
+    now?: () => number;
+}
+/**
+ * Records the active telescope store's `record` as a fire-and-forget sink,
+ * swallowing every failure — mirroring the watcher `safeRecord` contract so an
+ * ingest request can never be broken (or blocked) by a failing store.
+ */
+export declare function storeRecorder(store: TelescopeStore): (input: RecordInput<ClientExceptionContent>) => void;
+/**
+ * The framework-agnostic client-error ingestion handler. Mirrors the NestJS
+ * `ClientErrorController.ingest` pipeline in idiomatic AdonisJS form — the
+ * provider registers `POST <path>` and delegates to {@link handle}.
+ *
+ * Pipeline (each stage short-circuits): authorize hook → body byte cap (413) →
+ * per-IP rate limit (429) → structural validation (400) → overload-shed check →
+ * record as a `client_exception` entry and answer `204 No Content`.
+ */
+export declare class ClientErrorIngestor {
+    private readonly config;
+    private readonly record;
+    private readonly isPaused;
+    private readonly limiter;
+    /** One warn for an authorize-hook throw, so a flaky hook can't spam logs. */
+    private warnedAuthorize;
+    constructor(deps: ClientErrorIngestorDeps);
+    handle(ctx: ClientErrorHttpContext): Promise<unknown>;
+    /**
+     * Run the host's authorize hook defensively: a throw is a DENIAL (fail closed)
+     * and warn-logged once, so a buggy hook never 500s the public endpoint nor
+     * floods the logs.
+     */
+    private runAuthorize;
+    /**
+     * Best-effort serialized byte size of the parsed body. The framework already
+     * parsed JSON by the time we get here, so we re-serialize to measure bytes
+     * (UTF-8) — a tight enough proxy for the wire size to reject oversized
+     * payloads. A non-serializable body counts as 0 (it'll fail validation anyway).
+     */
+    private bodyByteSize;
+    /** The reporting client's IP via Adonis `request.ip()`, or `'unknown'`. */
+    private clientIp;
+}
+//# sourceMappingURL=ingestor.d.ts.map

package/dist/src/client_errors/ingestor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ingestor.d.ts","sourceRoot":"","sources":["../../../src/client_errors/ingestor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAG1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAC;AAE9D,OAAO,EACL,KAAK,sBAAsB,EAG5B,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB;IACjC,yDAAyD;IACzD,IAAI,IAAI,OAAO,CAAC;IAChB,0EAA0E;IAC1E,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IACzC,kFAAkF;IAClF,EAAE,IAAI,MAAM,GAAG,SAAS,CAAC;CAC1B;AAED,6DAA6D;AAC7D,MAAM,WAAW,mBAAmB;IAClC,iFAAiF;IACjF,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,mBAAmB,CAAC;IAC1C,6DAA6D;IAC7D,IAAI,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC;CAC9B;AAED,gFAAgF;AAChF,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,kBAAkB,CAAC;IAC5B,QAAQ,EAAE,mBAAmB,CAAC;CAC/B;AAED,+EAA+E;AAC/E,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,0BAA0B,CAAC;IACnC;;;;OAIG;IACH,MAAM,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,sBAAsB,CAAC,KAAK,IAAI,CAAC;IAC7D,wEAAwE;IACxE,QAAQ,CAAC,EAAE,MAAM,OAAO,CAAC;IACzB,yEAAyE;IACzE,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,cAAc,GACpB,CAAC,KAAK,EAAE,WAAW,CAAC,sBAAsB,CAAC,KAAK,IAAI,CAQtD;AAOD;;;;;;;;GAQG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA6B;IACpD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuD;IAC9E,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgB;IACzC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyB;IACjD,6EAA6E;IAC7E,OAAO,CAAC,eAAe,CAAS;gBAEpB,IAAI,EAAE,uBAAuB;IAUnC,MAAM,CAAC,GAAG,EAAE,sBAAsB,GAAG,OAAO,CAAC,OAAO,CAAC;IAwD3D;;;;OAIG;YACW,YAAY;IAmB1B;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAQpB,2EAA2E;IAC3E,OAAO,CAAC,QAAQ;CAIjB"}

package/dist/src/client_errors/ingestor.js

@@ -0,0 +1,135 @@
+import { EntryType } from '../entry.js';
+import { exceptionFamilyHash } from '../exception_family_hash.js';
+import { getTelescopeRuntime } from '../registry.js';
+import { ClientErrorRateLimiter } from './rate_limiter.js';
+import { userIdentityTag, validateClientErrorBody, } from './validation.js';
+/**
+ * Records the active telescope store's `record` as a fire-and-forget sink,
+ * swallowing every failure — mirroring the watcher `safeRecord` contract so an
+ * ingest request can never be broken (or blocked) by a failing store.
+ */
+export function storeRecorder(store) {
+    return (input) => {
+        try {
+            void Promise.resolve(store.record(input)).catch((err) => reportError(err));
+        }
+        catch (err) {
+            reportError(err);
+        }
+    };
+}
+function reportError(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`telescope client-errors: failed to record entry: ${message}`);
+}
+/**
+ * The framework-agnostic client-error ingestion handler. Mirrors the NestJS
+ * `ClientErrorController.ingest` pipeline in idiomatic AdonisJS form — the
+ * provider registers `POST <path>` and delegates to {@link handle}.
+ *
+ * Pipeline (each stage short-circuits): authorize hook → body byte cap (413) →
+ * per-IP rate limit (429) → structural validation (400) → overload-shed check →
+ * record as a `client_exception` entry and answer `204 No Content`.
+ */
+export class ClientErrorIngestor {
+    config;
+    record;
+    isPaused;
+    limiter;
+    /** One warn for an authorize-hook throw, so a flaky hook can't spam logs. */
+    warnedAuthorize = false;
+    constructor(deps) {
+        this.config = deps.config;
+        this.record = deps.record;
+        this.isPaused = deps.isPaused ?? (() => getTelescopeRuntime().paused);
+        this.limiter = new ClientErrorRateLimiter({
+            perMinute: this.config.rateLimitPerMinute,
+            ...(deps.now !== undefined ? { now: deps.now } : {}),
+        });
+    }
+    async handle(ctx) {
+        const config = this.config;
+        // 1) authorize hook runs FIRST (before any work): a session/header gate.
+        if (config.authorize !== undefined) {
+            if (!(await this.runAuthorize(config.authorize, ctx))) {
+                return ctx.response.status(403).send({ error: 'Forbidden' });
+            }
+        }
+        // 2) body byte cap, BEFORE validation, so a huge payload is cheap to reject.
+        const body = ctx.request.body();
+        if (this.bodyByteSize(body) > config.maxBodyBytes) {
+            return ctx.response.status(413).send({ error: 'Payload too large' });
+        }
+        // 3) per-IP rate limit (per-process, best-effort abuse dampening).
+        const ip = this.clientIp(ctx);
+        if (!this.limiter.tryConsume(ip)) {
+            return ctx.response.status(429).send({ error: 'Rate limit exceeded' });
+        }
+        // 4) structural validation — never trust the body; no echo on failure.
+        const validation = validateClientErrorBody(body);
+        if (!validation.ok) {
+            return ctx.response.status(400).send({ error: validation.reason });
+        }
+        // 5) overload shed: while the guard has paused ingestion, DROP the entry so
+        //    a lagging event loop is never made worse — but still answer 204 so the
+        //    browser treats it as accepted and does not retry-storm.
+        if (this.isPaused()) {
+            return ctx.response.status(204).send(null);
+        }
+        // 6) record through the normal pipeline: family-hash from name+message+top
+        //    frame (mirrors server exceptions), and the composing tags.
+        const content = validation.value;
+        const tags = ['failed', 'client'];
+        const userTag = userIdentityTag(content.user);
+        if (userTag !== null)
+            tags.push(userTag);
+        this.record({
+            type: EntryType.ClientException,
+            familyHash: exceptionFamilyHash({
+                name: content.name ?? '',
+                message: content.message,
+                stack: content.stack,
+            }),
+            tags,
+            content: { ...content, clientIp: ip === 'unknown' ? null : ip },
+        });
+        return ctx.response.status(204).send(null);
+    }
+    /**
+     * Run the host's authorize hook defensively: a throw is a DENIAL (fail closed)
+     * and warn-logged once, so a buggy hook never 500s the public endpoint nor
+     * floods the logs.
+     */
+    async runAuthorize(authorize, ctx) {
+        try {
+            return (await authorize(ctx)) === true;
+        }
+        catch (error) {
+            if (!this.warnedAuthorize) {
+                this.warnedAuthorize = true;
+                console.warn(`telescope client-errors authorize hook threw; treating as denial. ${error instanceof Error ? error.message : String(error)}`);
+            }
+            return false;
+        }
+    }
+    /**
+     * Best-effort serialized byte size of the parsed body. The framework already
+     * parsed JSON by the time we get here, so we re-serialize to measure bytes
+     * (UTF-8) — a tight enough proxy for the wire size to reject oversized
+     * payloads. A non-serializable body counts as 0 (it'll fail validation anyway).
+     */
+    bodyByteSize(body) {
+        try {
+            return Buffer.byteLength(JSON.stringify(body) ?? '', 'utf8');
+        }
+        catch {
+            return 0;
+        }
+    }
+    /** The reporting client's IP via Adonis `request.ip()`, or `'unknown'`. */
+    clientIp(ctx) {
+        const ip = ctx.request.ip();
+        return typeof ip === 'string' && ip.length > 0 ? ip : 'unknown';
+    }
+}
+//# sourceMappingURL=ingestor.js.map

package/dist/src/client_errors/ingestor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ingestor.js","sourceRoot":"","sources":["../../../src/client_errors/ingestor.ts"],"names":[],"mappings":"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"}

package/dist/src/client_errors/rate_limiter.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Default ceiling on the number of distinct IPs tracked at once. The limiter is
+ * the only state the public client-error endpoint keeps, so it MUST stay bounded
+ * — an attacker rotating source IPs (or sitting behind a large CGNAT/proxy pool)
+ * could otherwise grow the map without limit. At the cap we evict the OLDEST
+ * inserted IP, the one least likely to still be mid-burst, which is the right
+ * bias for a short-window rate limiter.
+ */
+declare const DEFAULT_MAX_TRACKED_IPS = 10000;
+/**
+ * A bounded, in-memory, per-IP token-bucket rate limiter for the PUBLIC
+ * client-error endpoint. Per-process by design (no cross-process coordination):
+ * in a multi-instance deployment the same client may get up to `perMinute`
+ * requests PER INSTANCE. The intent is cheap abuse-dampening on a public
+ * surface, not a hard global quota (a shared limiter would need a cross-process
+ * store, out of scope for this in-process slice).
+ *
+ * Each IP gets a bucket holding at most `perMinute` tokens that refills linearly
+ * at `perMinute / 60_000` tokens per ms. A request consumes one token; an empty
+ * bucket means "over the limit". The bucket map is capped (insertion-order
+ * eviction of the oldest IP) so memory can't grow without bound.
+ *
+ * Ported from the NestJS `nestjs-telescope` core client-error rate limiter.
+ */
+export declare class ClientErrorRateLimiter {
+    private readonly buckets;
+    private readonly perMinute;
+    private readonly maxTrackedIps;
+    private readonly refillPerMs;
+    private readonly now;
+    constructor(options: {
+        perMinute: number;
+        maxTrackedIps?: number;
+        /** Wall-clock seam (ms). Defaults to `Date.now`. */
+        now?: () => number;
+    });
+    /**
+     * Try to spend one token for `ip`. Returns `true` when the request is allowed
+     * (a token was available and consumed), `false` when the bucket is empty (over
+     * the limit). Refills the bucket continuously based on elapsed time so the
+     * effective rate is exactly `perMinute` without a coarse fixed window.
+     */
+    tryConsume(ip: string): boolean;
+    /** Number of tracked IPs (test/observability seam). */
+    get size(): number;
+    /**
+     * Insert a fresh bucket, evicting the oldest tracked IP first when at the cap.
+     * `Map` iterates in insertion order, so the first key is the oldest inserted.
+     */
+    private insert;
+}
+export { DEFAULT_MAX_TRACKED_IPS };
+//# sourceMappingURL=rate_limiter.d.ts.map

package/dist/src/client_errors/rate_limiter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate_limiter.d.ts","sourceRoot":"","sources":["../../../src/client_errors/rate_limiter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,QAAA,MAAM,uBAAuB,QAAS,CAAC;AASvC;;;;;;;;;;;;;;GAcG;AACH,qBAAa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6B;IACrD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;gBAEvB,OAAO,EAAE;QACnB,SAAS,EAAE,MAAM,CAAC;QAClB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,oDAAoD;QACpD,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;KACpB;IAUD;;;;;OAKG;IACH,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAmB/B,uDAAuD;IACvD,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;OAGG;IACH,OAAO,CAAC,MAAM;CAQf;AAED,OAAO,EAAE,uBAAuB,EAAE,CAAC"}

package/dist/src/client_errors/rate_limiter.js

@@ -0,0 +1,83 @@
+/**
+ * Default ceiling on the number of distinct IPs tracked at once. The limiter is
+ * the only state the public client-error endpoint keeps, so it MUST stay bounded
+ * — an attacker rotating source IPs (or sitting behind a large CGNAT/proxy pool)
+ * could otherwise grow the map without limit. At the cap we evict the OLDEST
+ * inserted IP, the one least likely to still be mid-burst, which is the right
+ * bias for a short-window rate limiter.
+ */
+const DEFAULT_MAX_TRACKED_IPS = 10_000;
+/**
+ * A bounded, in-memory, per-IP token-bucket rate limiter for the PUBLIC
+ * client-error endpoint. Per-process by design (no cross-process coordination):
+ * in a multi-instance deployment the same client may get up to `perMinute`
+ * requests PER INSTANCE. The intent is cheap abuse-dampening on a public
+ * surface, not a hard global quota (a shared limiter would need a cross-process
+ * store, out of scope for this in-process slice).
+ *
+ * Each IP gets a bucket holding at most `perMinute` tokens that refills linearly
+ * at `perMinute / 60_000` tokens per ms. A request consumes one token; an empty
+ * bucket means "over the limit". The bucket map is capped (insertion-order
+ * eviction of the oldest IP) so memory can't grow without bound.
+ *
+ * Ported from the NestJS `nestjs-telescope` core client-error rate limiter.
+ */
+export class ClientErrorRateLimiter {
+    buckets = new Map();
+    perMinute;
+    maxTrackedIps;
+    refillPerMs;
+    now;
+    constructor(options) {
+        // Guard against a misconfigured zero/negative rate turning into a divide
+        // that never refills; treat anything <= 0 as "allow 1/min" so the endpoint
+        // still functions rather than locking out every caller forever.
+        this.perMinute = options.perMinute > 0 ? options.perMinute : 1;
+        this.maxTrackedIps = options.maxTrackedIps ?? DEFAULT_MAX_TRACKED_IPS;
+        this.refillPerMs = this.perMinute / 60_000;
+        this.now = options.now ?? Date.now;
+    }
+    /**
+     * Try to spend one token for `ip`. Returns `true` when the request is allowed
+     * (a token was available and consumed), `false` when the bucket is empty (over
+     * the limit). Refills the bucket continuously based on elapsed time so the
+     * effective rate is exactly `perMinute` without a coarse fixed window.
+     */
+    tryConsume(ip) {
+        const nowMs = this.now();
+        const existing = this.buckets.get(ip);
+        if (existing === undefined) {
+            // First request from this IP: start full, immediately spend one token.
+            this.insert(ip, { tokens: this.perMinute - 1, lastRefillMs: nowMs });
+            return true;
+        }
+        const elapsedMs = nowMs - existing.lastRefillMs;
+        const refilled = Math.min(this.perMinute, existing.tokens + elapsedMs * this.refillPerMs);
+        existing.lastRefillMs = nowMs;
+        if (refilled < 1) {
+            existing.tokens = refilled;
+            return false;
+        }
+        existing.tokens = refilled - 1;
+        return true;
+    }
+    /** Number of tracked IPs (test/observability seam). */
+    get size() {
+        return this.buckets.size;
+    }
+    /**
+     * Insert a fresh bucket, evicting the oldest tracked IP first when at the cap.
+     * `Map` iterates in insertion order, so the first key is the oldest inserted.
+     */
+    insert(ip, bucket) {
+        while (this.buckets.size >= this.maxTrackedIps) {
+            const oldest = this.buckets.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.buckets.delete(oldest);
+        }
+        this.buckets.set(ip, bucket);
+    }
+}
+export { DEFAULT_MAX_TRACKED_IPS };
+//# sourceMappingURL=rate_limiter.js.map

package/dist/src/client_errors/rate_limiter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate_limiter.js","sourceRoot":"","sources":["../../../src/client_errors/rate_limiter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,uBAAuB,GAAG,MAAM,CAAC;AASvC;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,sBAAsB;IAChB,OAAO,GAAG,IAAI,GAAG,EAAkB,CAAC;IACpC,SAAS,CAAS;IAClB,aAAa,CAAS;IACtB,WAAW,CAAS;IACpB,GAAG,CAAe;IAEnC,YAAY,OAKX;QACC,yEAAyE;QACzE,2EAA2E;QAC3E,gEAAgE;QAChE,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;QAC/D,IAAI,CAAC,aAAa,GAAG,OAAO,CAAC,aAAa,IAAI,uBAAuB,CAAC;QACtE,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC;QAC3C,IAAI,CAAC,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,CAAC;IACrC,CAAC;IAED;;;;;OAKG;IACH,UAAU,CAAC,EAAU;QACnB,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACzB,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QACtC,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC3B,uEAAuE;YACvE,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,SAAS,GAAG,CAAC,EAAE,YAAY,EAAE,KAAK,EAAE,CAAC,CAAC;YACrE,OAAO,IAAI,CAAC;QACd,CAAC;QACD,MAAM,SAAS,GAAG,KAAK,GAAG,QAAQ,CAAC,YAAY,CAAC;QAChD,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC;QAC1F,QAAQ,CAAC,YAAY,GAAG,KAAK,CAAC;QAC9B,IAAI,QAAQ,GAAG,CAAC,EAAE,CAAC;YACjB,QAAQ,CAAC,MAAM,GAAG,QAAQ,CAAC;YAC3B,OAAO,KAAK,CAAC;QACf,CAAC;QACD,QAAQ,CAAC,MAAM,GAAG,QAAQ,GAAG,CAAC,CAAC;QAC/B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,uDAAuD;IACvD,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;IAC3B,CAAC;IAED;;;OAGG;IACK,MAAM,CAAC,EAAU,EAAE,MAAc;QACvC,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YAC/C,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC;YAChD,IAAI,MAAM,KAAK,SAAS;gBAAE,MAAM;YAChC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAC9B,CAAC;QACD,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;IAC/B,CAAC;CACF;AAED,OAAO,EAAE,uBAAuB,EAAE,CAAC"}

package/dist/src/client_errors/validation.d.ts

@@ -0,0 +1,62 @@
+/**
+ * A browser-reported error ingested via the public client-error endpoint (see
+ * {@link EntryType.ClientException}). Everything beyond `message` is optional
+ * because the browser is UNTRUSTED — {@link validateClientErrorBody} validates
+ * the structure and length-caps the strings before recording, and `extra` (an
+ * arbitrary, host-defined bag of debugging context) is bounded by the normal
+ * redaction budget at record time exactly like every other content payload.
+ *
+ * Field intent mirrors the NestJS `nestjs-telescope` core:
+ *  - `message`        — the error message (required; the one field we insist on).
+ *  - `name`           — the error class/name (e.g. `TypeError`); feeds the family hash.
+ *  - `stack`          — the JS stack string; its TOP frame also feeds the family hash.
+ *  - `componentStack` — React's component stack (from an error boundary).
+ *  - `url`            — the page URL where the error happened.
+ *  - `userAgent`      — the reporting browser's UA string.
+ *  - `user`           — host-supplied user identity (pivoted into a `user:<id>` tag).
+ *  - `release`        — an app version / build id, so errors group by deploy.
+ *  - `extra`          — free-form debugging context; redacted/bounded like any content.
+ *  - `clientIp`       — filled in BY THE SERVER from `request.ip()`; never from the body.
+ */
+export interface ClientExceptionContent {
+    message: string;
+    name: string | null;
+    stack: string | null;
+    componentStack: string | null;
+    url: string | null;
+    userAgent: string | null;
+    user: unknown;
+    release: string | null;
+    extra: Record<string, unknown> | null;
+    clientIp: string | null;
+}
+/**
+ * The successful parse result. We DELIBERATELY do not echo the raw payload back
+ * to the client on failure (see {@link validateClientErrorBody}) — the caller
+ * gets a generic 400 with a fixed reason, never a reflection of what it sent.
+ */
+export type ClientErrorValidation = {
+    ok: true;
+    value: Omit<ClientExceptionContent, 'clientIp'>;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Structurally validate an UNTRUSTED client-error body WITHOUT adding a schema
+ * dependency. Rules: `message` is a required non-empty string; every other field
+ * is optional with a type check and a length cap; `user` is passed through as-is
+ * (redacted at record time) and `extra` must be a plain object if present (its
+ * contents are bounded by redaction, not here). On any violation returns a
+ * generic reason and NO echo of the payload, so the endpoint never reflects
+ * attacker input.
+ */
+export declare function validateClientErrorBody(body: unknown): ClientErrorValidation;
+/**
+ * The `user:<id>` tag for a raw user value, or `null` when no usable identity is
+ * present. Prefers `id`, then `_id`, then `email` — so an error reported from a
+ * browser tags identically to a server request. Cheap property reads; never throws.
+ * Ported from the `nestjs-telescope` tagger's `userIdentityTag`.
+ */
+export declare function userIdentityTag(user: unknown): string | null;
+//# sourceMappingURL=validation.d.ts.map

package/dist/src/client_errors/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/client_errors/validation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACtC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AAgBD;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAC7B;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,IAAI,CAAC,sBAAsB,EAAE,UAAU,CAAC,CAAA;CAAE,GAC7D;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAqBlC;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,OAAO,GAAG,qBAAqB,CA+C5E;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAK5D"}

package/dist/src/client_errors/validation.js

@@ -0,0 +1,109 @@
+/**
+ * Length caps for the validated string fields. The browser is UNTRUSTED, so we
+ * bound every string before recording — a stack can be large but not unbounded,
+ * and short fields (message/url/userAgent) get a tight cap. Arrays/objects under
+ * `extra` are NOT capped here; they pass through the redaction budget
+ * (depth/string/array/node bounds) at record time exactly like all other content.
+ */
+const STACK_MAX = 16 * 1024;
+const COMPONENT_STACK_MAX = 16 * 1024;
+const MESSAGE_MAX = 2 * 1024;
+const SHORT_FIELD_MAX = 2 * 1024;
+const NAME_MAX = 256;
+const RELEASE_MAX = 256;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Read an OPTIONAL string field: missing/`null`/`undefined` yields `null`; a
+ * present non-string is a hard validation failure (we don't silently coerce
+ * untrusted input); a present string is length-capped.
+ */
+function optionalString(value, field, max) {
+    if (value === undefined || value === null)
+        return { ok: true, value: null };
+    if (typeof value !== 'string')
+        return { ok: false, reason: `\`${field}\` must be a string` };
+    return { ok: true, value: value.length > max ? value.slice(0, max) : value };
+}
+/**
+ * Structurally validate an UNTRUSTED client-error body WITHOUT adding a schema
+ * dependency. Rules: `message` is a required non-empty string; every other field
+ * is optional with a type check and a length cap; `user` is passed through as-is
+ * (redacted at record time) and `extra` must be a plain object if present (its
+ * contents are bounded by redaction, not here). On any violation returns a
+ * generic reason and NO echo of the payload, so the endpoint never reflects
+ * attacker input.
+ */
+export function validateClientErrorBody(body) {
+    if (!isRecord(body)) {
+        return { ok: false, reason: 'Body must be a JSON object' };
+    }
+    const message = body.message;
+    if (typeof message !== 'string' || message.length === 0) {
+        return { ok: false, reason: '`message` is required and must be a non-empty string' };
+    }
+    const cappedMessage = message.length > MESSAGE_MAX ? message.slice(0, MESSAGE_MAX) : message;
+    const name = optionalString(body.name, 'name', NAME_MAX);
+    if (!name.ok)
+        return name;
+    const stack = optionalString(body.stack, 'stack', STACK_MAX);
+    if (!stack.ok)
+        return stack;
+    const componentStack = optionalString(body.componentStack, 'componentStack', COMPONENT_STACK_MAX);
+    if (!componentStack.ok)
+        return componentStack;
+    const url = optionalString(body.url, 'url', SHORT_FIELD_MAX);
+    if (!url.ok)
+        return url;
+    const userAgent = optionalString(body.userAgent, 'userAgent', SHORT_FIELD_MAX);
+    if (!userAgent.ok)
+        return userAgent;
+    const release = optionalString(body.release, 'release', RELEASE_MAX);
+    if (!release.ok)
+        return release;
+    let extra = null;
+    if (body.extra !== undefined && body.extra !== null) {
+        if (!isRecord(body.extra)) {
+            return { ok: false, reason: '`extra` must be an object' };
+        }
+        extra = body.extra;
+    }
+    return {
+        ok: true,
+        value: {
+            message: cappedMessage,
+            name: name.value,
+            stack: stack.value,
+            componentStack: componentStack.value,
+            url: url.value,
+            userAgent: userAgent.value,
+            // `user` is intentionally untyped passthrough: redacted at record time and
+            // pivoted into a `user:<id>` tag via userIdentityTag.
+            user: 'user' in body ? body.user : null,
+            release: release.value,
+            extra,
+        },
+    };
+}
+/**
+ * The `user:<id>` tag for a raw user value, or `null` when no usable identity is
+ * present. Prefers `id`, then `_id`, then `email` — so an error reported from a
+ * browser tags identically to a server request. Cheap property reads; never throws.
+ * Ported from the `nestjs-telescope` tagger's `userIdentityTag`.
+ */
+export function userIdentityTag(user) {
+    if (typeof user !== 'object' || user === null)
+        return null;
+    const record = user;
+    const id = identityToken(record.id) ?? identityToken(record._id) ?? identityToken(record.email);
+    return id === null ? null : `user:${id}`;
+}
+function identityToken(value) {
+    if (typeof value === 'string')
+        return value.length > 0 ? value : null;
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? String(value) : null;
+    return null;
+}
+//# sourceMappingURL=validation.js.map

package/dist/src/client_errors/validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.js","sourceRoot":"","sources":["../../../src/client_errors/validation.ts"],"names":[],"mappings":"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"}