@autter/otlp-ingester 1.9.0 → 1.11.0

package/dist/server.js

@@ -1,14 +1,15 @@
 import express from "express";
 import { KeyResolver, RateLimiter } from "./auth.js";
 import { countTruncations } from "./context.js";
-import { autterKeyHash, cumulativeHttpHistogramPoints, dataPointsInRequest, dropRoute, IngestDropCounter, PARTIAL_MESSAGES, partialSuccess, recordsInBody, spansInRequest, } from "./ingest-drops.js";
+import { autterKeyHash, caughtLimitedRecords, cumulativeHttpHistogramPoints, dataPointsInRequest, dropRoute, IngestDropCounter, PARTIAL_MESSAGES, partialSuccess, recordsInBody, spansInRequest, } from "./ingest-drops.js";
 import { ClickHouseStore } from "./clickhouse.js";
 import { normalizeLatencyHistograms } from "./latency.js";
 import { deriveFields, occurrenceIdFor } from "./fingerprint.js";
+import { causeTexts } from "./cause-chain.js";
 import { occurrenceIdentity } from "./fingerprint-v3.js";
 import { parseStackFrames } from "./stack-frames.js";
 import { SourceMapCache, Symbolicator } from "./symbolicate.js";
-import { logPromotionCandidates, promotionLookups, promotionRollups, } from "./log-promotion.js";
+import { logPromotionCandidates, promotionLookups, logRollups, } from "./log-promotion.js";
 import { normalizeBrowserPayload, parseBrowserPayload, } from "./normalize-browser.js";
 import { normalizeMetrics, normalizeTraces, } from "./normalize-otlp.js";
 import { decodeMetricsRequest, decodeTraceRequest, decodeLogsRequest, encodeExportResponse } from "./otlp-proto.js";
@@ -45,8 +46,9 @@ const INGESTER_INFO_INTERVAL_MS = 6 * 60 * 60 * 1000;
 export function createIngesterApp(config) {
     configureRedaction(config);
     const store = new ClickHouseStore(config);
-    // Browser JS frames are resolved through uploaded source maps before they
-    // are fingerprinted (frames-v3), with parsed maps cached per release+file.
+    // Browser, Node and edge JS frames are resolved through uploaded source
+    // maps before they are fingerprinted (frames-v3), with parsed maps cached
+    // per release+file.
     const symbolicator = new Symbolicator((key) => store.lookupSourceMap(key), new SourceMapCache({ maxBytes: (config.sourceMapCacheMb ?? 64) * 1024 * 1024 }));
     // Fingerprinted occurrences feed the consumer's issue grouping, metric
     // points feed the request/error-rate rollups, LLM calls feed spend
@@ -392,30 +394,63 @@ export function createIngesterApp(config) {
         }
         return ctx;
     }
-    /**
-     * Structured frames for the frames-v3 identity and the platform's stack
-     * view: parsed innermost-first, then — browser only, where bundles are
-     * minified — resolved through the release's source maps. Symbolication
-     * never fails ingest (it falls back to the parsed frames).
-     */
-    async function framesFor(ctx, input) {
-        let frames;
+    /** A stack's frames, innermost first; none when it does not parse. */
+    function parsedFrames(stack) {
         try {
-            frames = parseStackFrames(input.stack);
+            return parseStackFrames(stack);
         }
         catch (err) {
             console.warn("stack parse failed — no frames:", err instanceof Error ? err.message : err);
             return [];
         }
-        if (input.source !== "browser" || frames.length === 0)
-            return frames;
+    }
+    /**
+     * Frames resolved through the release's source maps: minified browser
+     * bundles, and bundled Node and edge code (RF-05: tsup, esbuild, webpack
+     * and Next.js server output) — only JS frames a map was uploaded for
+     * change. Never fails ingest (it falls back to the parsed frames).
+     */
+    function symbolicated(ctx, input, frames) {
+        if (frames.length === 0)
+            return Promise.resolve(frames);
         return symbolicator.symbolicate(frames, {
             orgId: ctx.orgId,
             repositoryId: ctx.repositoryId,
             release: input.release,
             debugIds: input.debugIds ?? null,
+            server: input.source !== "browser",
         });
     }
+    /**
+     * Structured frames for the frames-v3 identity and the platform's stack
+     * view: parsed innermost-first, then resolved through the release's
+     * source maps, with context lines on in-app frames when the map carries
+     * their source.
+     */
+    function framesFor(ctx, input) {
+        return symbolicated(ctx, input, parsedFrames(input.stack));
+    }
+    /**
+     * The reported exception's causes, nearest first, with their frames
+     * resolved like the reported one's (RF-06: the cause-v1 identity hashes
+     * the root cause's innermost in-app frame, which must read the same as
+     * when that error is reported unwrapped). Only used for the identity:
+     * cause frames are not stored.
+     */
+    async function causesFor(ctx, input) {
+        let causes;
+        try {
+            causes = causeTexts(input.stack, input.attributes);
+        }
+        catch (err) {
+            console.warn("cause chain parse failed — no causes:", err instanceof Error ? err.message : err);
+            return [];
+        }
+        return Promise.all(causes.map(async (cause) => ({
+            type: cause.type,
+            frames: await symbolicated(ctx, input, parsedFrames(cause.stack)),
+        })));
+    }
     /** Ids are content-derived (occurrenceIdFor), NOT random: an exporter
      * that retries a batch — after a 503 from a partially-failed ClickHouse
      * write, or when only our 2xx got lost — must produce the same ids, so
@@ -424,8 +459,8 @@ export function createIngesterApp(config) {
      *
      * `fingerprint` / `fingerprintScheme` stay the legacy identity
      * (message-v1 or code-v1) byte-for-byte; `fingerprints` carries every
-     * candidate (manual-v1, code-v1, frames-v3, message-v1) for the platform
-     * to resolve the issue from.
+     * candidate (manual-v1, code-v1, frames-v3, message-v1, cause-v1) for
+     * the platform to resolve the issue from.
      *
      * `batchIndexes` (traces): each occurrence's position among the batch's
      * signals before the per-trace dedupe, so a merged occurrence keeps the
@@ -439,8 +474,8 @@ export function createIngesterApp(config) {
             // through verbatim. Attributes were already sanitised by the
             // normalisers (sanitizeRuntimeContext).
             const input = scrubOccurrence(raw);
-            const frames = await framesFor(ctx, input);
-            const identity = occurrenceIdentity(input, frames);
+            const [frames, causes] = await Promise.all([framesFor(ctx, input), causesFor(ctx, input)]);
+            const identity = occurrenceIdentity(input, frames, causes);
             const { fingerprint, scheme } = identity.legacy;
             // Debug ids only locate source maps; they are not stored or forwarded.
             const { debugIds: _debugIds, ...stored } = input;
@@ -672,6 +707,7 @@ export function createIngesterApp(config) {
         countAccepted(ctx, req, [
             { reason: "spans_over_limit", records: overLimit },
             { reason: "attributes_truncated", records: truncated },
+            { reason: "caught_limited", records: caughtLimitedRecords(occurrences.map((o) => o.attributes)) },
         ]);
     }));
     app.post("/v1/logs", asyncRoute(async (req, res) => {
@@ -700,7 +736,7 @@ export function createIngesterApp(config) {
         // and those are promoted to occurrences here — see log-promotion.ts.
         const promoted = await promoteLogs(ctx, logs);
         // Rollups count every promoted error, collapsed or suppressed ones too.
-        const metricPoints = promotionRollups(promoted);
+        const metricPoints = logRollups(logs, promoted);
         const admitted = admit(ctx, req, promoted);
         try {
             await Promise.all([
@@ -723,6 +759,8 @@ export function createIngesterApp(config) {
         countAccepted(ctx, req, [
             { reason: "log_records_over_limit", records: stats.overLimit },
             { reason: "attributes_truncated", records: truncated },
+            // Every record, promoted or not (the SDK's own count records too).
+            { reason: "caught_limited", records: caughtLimitedRecords(logs.map((row) => row.attributes)) },
         ]);
     }));
     app.post("/v1/metrics", asyncRoute(async (req, res) => {

package/dist/sink.d.ts

@@ -127,7 +127,10 @@ export declare class SinkForwarder {
  * keep their legacy meaning. 1.9.0 adds `count`: the occurrences this
  * record stands for, sent only when above 1 (a loop-collapse sample:
  * 1 + collapsedCount, see loop-collapse.ts); consumers add `count ?? 1` to
- * their event counts. Older consumers ignore unknown keys, so the version
- * stays 1.
+ * their event counts. Unreleased (RF-06): `fingerprints` may end with a
+ * `cause-v1` candidate after the legacy one; consumers that do not know the
+ * scheme drop it (the platform validates schemes one by one). RF-05: in-app
+ * frames' context lines are up to 5 on each side (3 before). Older consumers
+ * ignore unknown keys, so the version stays 1.
  */
 export declare function sinkOccurrence(o: RuntimeOccurrence): Record<string, unknown>;

package/dist/sink.js

@@ -120,7 +120,8 @@ export class SinkForwarder {
             orgId: ctx.orgId,
             repositoryId: ctx.repositoryId,
             occurrences: occurrences.map(sinkOccurrence),
-            metrics: metricPoints.map((p) => ({
+            // Latency samples feed runtime_route_latency_1m only (IP-02).
+            metrics: metricPoints.map(({ latency: _latency, ...p }) => ({
                 ...p,
                 bucketAt: p.bucketAt.toISOString(),
             })),
@@ -322,8 +323,11 @@ export class SinkForwarder {
  * keep their legacy meaning. 1.9.0 adds `count`: the occurrences this
  * record stands for, sent only when above 1 (a loop-collapse sample:
  * 1 + collapsedCount, see loop-collapse.ts); consumers add `count ?? 1` to
- * their event counts. Older consumers ignore unknown keys, so the version
- * stays 1.
+ * their event counts. Unreleased (RF-06): `fingerprints` may end with a
+ * `cause-v1` candidate after the legacy one; consumers that do not know the
+ * scheme drop it (the platform validates schemes one by one). RF-05: in-app
+ * frames' context lines are up to 5 on each side (3 before). Older consumers
+ * ignore unknown keys, so the version stays 1.
  */
 export function sinkOccurrence(o) {
     const { traceId, route, method, statusCode, errorCode, why, fix, link, expected, requestId, breadcrumbs, frames, fingerprints, fingerprintRecord, 

package/dist/source-maps-lookup.d.ts

@@ -11,8 +11,21 @@ export interface SourceMapKey {
     release: string | null;
     filename: string;
     debugId?: string | null;
+    /**
+     * Server frames (RF-05): `filename` is the path the process ran the
+     * bundle from (`/app/dist/server.js`, `/var/task/.next/server/app/page.js`),
+     * which the upload can't know. Without a debug id, the release's map
+     * whose stored path is the longest suffix of it wins (`/server.js`,
+     * `/.next/server/app/page.js`); an exact path is the longest suffix of all.
+     */
+    suffix?: boolean;
 }
-/** The stored map JSON for a minified file: by debug id first when given, else by release + filename (path only, no origin/query). Null when none. */
+/**
+ * The stored map JSON for a minified file: by debug id first when given,
+ * else by release + filename (path only, no origin/query) — for a server
+ * frame (`suffix`), the release's map stored under the longest suffix of
+ * its path. Null when none.
+ */
 export declare function lookupSourceMap(client: ClickHouseClient, database: string, key: SourceMapKey): Promise<string | null>;
 /**
  * Re-uploading a map refreshes its 30-day TTL, so a map only counts as

package/dist/source-maps-lookup.js

@@ -1,16 +1,21 @@
 import { normalizeDebugId, sourceMapPath, } from "./source-maps.js";
-async function firstMap(client, database, where, params) {
+async function firstMap(client, database, where, params, order = "uploaded_at DESC") {
     const rows = await client.query({
         query: `SELECT map FROM ${database}.runtime_source_maps
 			WHERE org_id = {org:String} AND repository_id = {repo:String} AND ${where}
-			ORDER BY uploaded_at DESC LIMIT 1`,
+			ORDER BY ${order} LIMIT 1`,
         query_params: params,
         format: "JSONEachRow",
     });
     const [row] = await rows.json();
     return row?.map ?? null;
 }
-/** The stored map JSON for a minified file: by debug id first when given, else by release + filename (path only, no origin/query). Null when none. */
+/**
+ * The stored map JSON for a minified file: by debug id first when given,
+ * else by release + filename (path only, no origin/query) — for a server
+ * frame (`suffix`), the release's map stored under the longest suffix of
+ * its path. Null when none.
+ */
 export async function lookupSourceMap(client, database, key) {
     const tenant = { org: key.orgId, repo: key.repositoryId };
     // A debug id names the exact bundle bytes, so it matches whatever release
@@ -25,6 +30,11 @@ export async function lookupSourceMap(client, database, key) {
     const filename = sourceMapPath(key.filename);
     if (!key.release || !filename)
         return null;
+    if (key.suffix) {
+        // Stored paths always start with "/", so a suffix match ends on a
+        // path segment boundary. The release scan is a primary-key range.
+        return firstMap(client, database, "release = {release:String} AND endsWith({filename:String}, filename)", { ...tenant, release: key.release, filename }, "length(filename) DESC, uploaded_at DESC");
+    }
     return firstMap(client, database, "release = {release:String} AND filename = {filename:String}", { ...tenant, release: key.release, filename });
 }
 /**

package/dist/source-maps.d.ts

@@ -1,9 +1,11 @@
 /**
- * Largest stored map (after `sourcesContent` is removed), in characters:
- * 32 MiB, room for vendor chunks of about 20 MB of minified code. Storage
- * is a ZSTD-compressed String column, so size only costs disk; a map this
- * big is still symbolicated, without being kept in the parse cache unless
- * SOURCE_MAP_CACHE_MB allows it (symbolicate.ts). Was 5 MiB up to 1.6.0.
+ * Largest stored map, in characters: 32 MiB, room for vendor chunks of
+ * about 20 MB of minified code. Storage is a ZSTD-compressed String column,
+ * so size only costs disk; a map this big is still symbolicated, without
+ * being kept in the parse cache unless SOURCE_MAP_CACHE_MB allows it
+ * (symbolicate.ts). Was 5 MiB up to 1.6.0. The map without
+ * `sourcesContent` must fit it; the source contents kept (RF-05) fit in
+ * what is left of it, counted in UTF-8 bytes (storedSourcesContent).
  */
 export declare const SOURCE_MAP_MAX_CHARS: number;
 /** `/v1/sourcemaps` body limit, counted after a gzip or deflate body is
@@ -28,7 +30,7 @@ export interface ValidSourceMap {
     release: string;
     /** sourceMapPath() of the uploaded filename. */
     filename: string;
-    /** The map JSON without `sourcesContent`. */
+    /** The map JSON as stored: `sourcesContent` bounded by storedSourceMapJson. */
     map: string;
     /** Lowercase debug id, or "" when the upload has none. */
     debugId: string;
@@ -38,6 +40,30 @@ export interface ValidSourceMap {
 /** The content hash of a stored map — `autter-runtime sourcemaps upload`
  * computes the same value to skip maps the ingester already has. */
 export declare function sourceMapContentHash(map: string): string;
+/**
+ * The `sourcesContent` a stored map keeps (RF-05), or null to leave the
+ * field out. Context lines for in-app frames come from it, so only in-app
+ * sources keep theirs: a source the map's `ignoreList` /
+ * `x_google_ignoreList` names, or whose path the in-app rule rejects
+ * (`node_modules/`, `/.pnpm/`, `/vendor/`, … — isInAppPath), gets `null`,
+ * like any entry that is not a string.
+ *
+ * The map must stay within the stored-map limit, so contents are kept
+ * whole, smallest first (ties in source order), while the whole JSON fits
+ * `limit` UTF-8 bytes given the `baseBytes` of the map without the field;
+ * the rest become `null`. Nothing is ever cut inside a file, so kept line
+ * numbers stay right. `@autter/runtime-cli` (upload.ts storedMapJson) does
+ * exactly this, so it hashes the map the ingester stores and skips it on
+ * the next run.
+ */
+export declare function storedSourcesContent(fields: Record<string, unknown>, baseBytes: number, limit?: number): Array<string | null> | null;
+/**
+ * The stored JSON of a map: every field as sent except `sourcesContent`,
+ * which goes last, bounded by storedSourcesContent (left out when nothing
+ * is kept, so a map without in-app contents is stored byte-for-byte as it
+ * was before contents were kept).
+ */
+export declare function storedSourceMapJson(fields: Record<string, unknown>, limit?: number): string;
 /**
  * Validate one `/v1/sourcemaps` upload: `{ release, filename, map, debugId? }`.
  * `map` may be an object or a JSON string. The debug id comes from the body,
@@ -78,3 +104,20 @@ export declare const DEBUG_IDS_MAX = 50;
 export declare function browserDebugIds(raw: Record<string, unknown> | undefined): {
     debugIds?: Record<string, string>;
 };
+/**
+ * The attribute server SDKs put the debug ids of the bundles in an
+ * exception's stack under (`@autter/runtime-core` errorAttributes, RF-05):
+ * a JSON object of script path, as it appears in the stack → debug id.
+ */
+export declare const DEBUG_IDS_ATTRIBUTE = "autter.debug_ids";
+/**
+ * `{ debugIds }` from a server exception's `autter.debug_ids` (a JSON
+ * string, or the object the sanitiser made of it), validated exactly like a
+ * browser event's (browserDebugIds); `{}` when absent or malformed. Only
+ * locates source maps: like the browser's, never stored or forwarded.
+ */
+export declare function serverDebugIds(raw: unknown): {
+    debugIds?: Record<string, string>;
+};
+/** `attributes` without `autter.debug_ids`, which locates maps and is not kept. */
+export declare function withoutDebugIdsAttribute(attributes: Record<string, unknown>): Record<string, unknown>;

package/dist/source-maps.js

@@ -1,11 +1,14 @@
 import { createHash } from "node:crypto";
 import { scrubText } from "./redact.js";
+import { isInAppPath } from "./stack-frames.js";
 /**
- * Largest stored map (after `sourcesContent` is removed), in characters:
- * 32 MiB, room for vendor chunks of about 20 MB of minified code. Storage
- * is a ZSTD-compressed String column, so size only costs disk; a map this
- * big is still symbolicated, without being kept in the parse cache unless
- * SOURCE_MAP_CACHE_MB allows it (symbolicate.ts). Was 5 MiB up to 1.6.0.
+ * Largest stored map, in characters: 32 MiB, room for vendor chunks of
+ * about 20 MB of minified code. Storage is a ZSTD-compressed String column,
+ * so size only costs disk; a map this big is still symbolicated, without
+ * being kept in the parse cache unless SOURCE_MAP_CACHE_MB allows it
+ * (symbolicate.ts). Was 5 MiB up to 1.6.0. The map without
+ * `sourcesContent` must fit it; the source contents kept (RF-05) fit in
+ * what is left of it, counted in UTF-8 bytes (storedSourcesContent).
  */
 export const SOURCE_MAP_MAX_CHARS = 32 * 1024 * 1024;
 /** `/v1/sourcemaps` body limit, counted after a gzip or deflate body is
@@ -62,6 +65,78 @@ const RELEASE_RE = /^[a-zA-Z0-9._-]{1,200}$/;
 export function sourceMapContentHash(map) {
     return createHash("sha256").update(map).digest("hex");
 }
+/** UTF-8 bytes `,"sourcesContent":[` and `]` add around the entries. */
+const SOURCES_CONTENT_WRAPPER_BYTES = Buffer.byteLength(',"sourcesContent":[]');
+/** UTF-8 bytes of a `null` entry. */
+const NULL_ENTRY_BYTES = 4;
+/**
+ * The `sourcesContent` a stored map keeps (RF-05), or null to leave the
+ * field out. Context lines for in-app frames come from it, so only in-app
+ * sources keep theirs: a source the map's `ignoreList` /
+ * `x_google_ignoreList` names, or whose path the in-app rule rejects
+ * (`node_modules/`, `/.pnpm/`, `/vendor/`, … — isInAppPath), gets `null`,
+ * like any entry that is not a string.
+ *
+ * The map must stay within the stored-map limit, so contents are kept
+ * whole, smallest first (ties in source order), while the whole JSON fits
+ * `limit` UTF-8 bytes given the `baseBytes` of the map without the field;
+ * the rest become `null`. Nothing is ever cut inside a file, so kept line
+ * numbers stay right. `@autter/runtime-cli` (upload.ts storedMapJson) does
+ * exactly this, so it hashes the map the ingester stores and skips it on
+ * the next run.
+ */
+export function storedSourcesContent(fields, baseBytes, limit = SOURCE_MAP_MAX_CHARS) {
+    const { sources, sourcesContent } = fields;
+    if (!Array.isArray(sources) || !Array.isArray(sourcesContent) || sources.length === 0)
+        return null;
+    const ignored = new Set();
+    for (const list of [fields.ignoreList, fields.x_google_ignoreList]) {
+        if (!Array.isArray(list))
+            continue;
+        for (const index of list)
+            if (Number.isInteger(index))
+                ignored.add(index);
+    }
+    const count = sources.length;
+    const candidates = [];
+    for (let index = 0; index < count; index++) {
+        const source = sources[index];
+        const content = sourcesContent[index];
+        if (typeof source !== "string" || typeof content !== "string")
+            continue;
+        if (ignored.has(index) || !isInAppPath(source))
+            continue;
+        candidates.push({ index, content, bytes: Buffer.byteLength(JSON.stringify(content)) });
+    }
+    if (candidates.length === 0)
+        return null;
+    candidates.sort((a, b) => a.bytes - b.bytes || a.index - b.index);
+    // Every entry starts as `null`, with a comma between entries.
+    let remaining = limit - baseBytes - SOURCES_CONTENT_WRAPPER_BYTES - NULL_ENTRY_BYTES * count - (count - 1);
+    const kept = new Array(count).fill(null);
+    let any = false;
+    for (const candidate of candidates) {
+        const extra = candidate.bytes - NULL_ENTRY_BYTES;
+        if (extra > remaining)
+            break;
+        remaining -= extra;
+        kept[candidate.index] = candidate.content;
+        any = true;
+    }
+    return any ? kept : null;
+}
+/**
+ * The stored JSON of a map: every field as sent except `sourcesContent`,
+ * which goes last, bounded by storedSourcesContent (left out when nothing
+ * is kept, so a map without in-app contents is stored byte-for-byte as it
+ * was before contents were kept).
+ */
+export function storedSourceMapJson(fields, limit = SOURCE_MAP_MAX_CHARS) {
+    const { sourcesContent: _content, ...rest } = fields;
+    const base = JSON.stringify(rest);
+    const content = storedSourcesContent(fields, Buffer.byteLength(base), limit);
+    return content ? JSON.stringify({ ...rest, sourcesContent: content }) : base;
+}
 /**
  * Validate one `/v1/sourcemaps` upload: `{ release, filename, map, debugId? }`.
  * `map` may be an object or a JSON string. The debug id comes from the body,
@@ -92,14 +167,16 @@ export function validateSourceMap(body) {
     const debugId = rawDebugId === undefined || rawDebugId === null || rawDebugId === "" ? "" : normalizeDebugId(rawDebugId);
     if (debugId === null)
         return null;
-    // Source contents are unnecessary for position lookup and may contain
-    // secrets. Everything else is stored as sent, extension fields included:
-    // symbolication reads `x_autter_scopes` (function scopes) from it, and the
-    // CLI hashes exactly this JSON to skip maps already uploaded.
-    const { sourcesContent: _omitted, ...safe } = parsed;
-    const map = JSON.stringify(safe);
-    if (map.length > SOURCE_MAP_MAX_CHARS)
+    // Everything is stored as sent, extension fields included: symbolication
+    // reads `x_autter_scopes` (function scopes) from it, and the CLI hashes
+    // exactly this JSON to skip maps already uploaded. `sourcesContent` is
+    // kept for in-app sources (RF-05: context lines around in-app frames),
+    // within the stored-map limit; the lines taken from it are scrubbed when
+    // they are attached to an occurrence (symbolicate.ts).
+    const { sourcesContent: _content, ...withoutContent } = parsed;
+    if (JSON.stringify(withoutContent).length > SOURCE_MAP_MAX_CHARS)
         return null;
+    const map = storedSourceMapJson(parsed);
     return { release: input.release, filename, map, debugId, contentHash: sourceMapContentHash(map) };
 }
 /** Most entries one check request may name. */
@@ -167,3 +244,36 @@ export function browserDebugIds(raw) {
     }
     return count ? { debugIds } : {};
 }
+/**
+ * The attribute server SDKs put the debug ids of the bundles in an
+ * exception's stack under (`@autter/runtime-core` errorAttributes, RF-05):
+ * a JSON object of script path, as it appears in the stack → debug id.
+ */
+export const DEBUG_IDS_ATTRIBUTE = "autter.debug_ids";
+/**
+ * `{ debugIds }` from a server exception's `autter.debug_ids` (a JSON
+ * string, or the object the sanitiser made of it), validated exactly like a
+ * browser event's (browserDebugIds); `{}` when absent or malformed. Only
+ * locates source maps: like the browser's, never stored or forwarded.
+ */
+export function serverDebugIds(raw) {
+    let value = raw;
+    if (typeof value === "string") {
+        try {
+            value = JSON.parse(value);
+        }
+        catch {
+            return {};
+        }
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return {};
+    return browserDebugIds(value);
+}
+/** `attributes` without `autter.debug_ids`, which locates maps and is not kept. */
+export function withoutDebugIdsAttribute(attributes) {
+    if (!(DEBUG_IDS_ATTRIBUTE in attributes))
+        return attributes;
+    const { [DEBUG_IDS_ATTRIBUTE]: _ids, ...rest } = attributes;
+    return rest;
+}