@autter/otlp-ingester 1.6.0 → 1.6.1

package/README.md

@@ -75,7 +75,7 @@ the Autter dashboard reads both. See [docs/COMPATIBILITY.md](../../docs/COMPATIB
 | `SINK_MAX_ATTEMPTS` | `12` | Delivery attempts per batch (1–60 s backoff) |
 | `SINK_MAX_BUFFERED_BATCHES` | `1000` | Retry buffer cap; oldest drops are logged |
 | `SINK_MAX_BUFFERED_MB` | `64` | Sink retry buffer cap (memory) |
-| `SOURCE_MAP_CACHE_MB` | `64` | Memory budget (estimated decoded size) for parsed source maps used to symbolicate browser frames at ingest; least recently used maps are evicted |
+| `SOURCE_MAP_CACHE_MB` | `64` | Memory budget (decoded size, function scope tables included) for parsed source maps used to symbolicate browser frames at ingest; least recently used maps are evicted, and a map that needs more than half of it is used without being kept |
 | `MAX_BODY_BYTES` | `1048576` | Request body cap |
 | `RATE_LIMIT_PER_MINUTE` | `300` | Per-key fixed window (server keys) |
 | `CLIENT_RATE_LIMIT_PER_MINUTE` | `120` | Per-key fixed window (client keys) |

package/dist/clickhouse.js

@@ -19,6 +19,9 @@ const INSERT_SETTINGS = {
     async_insert: 1,
     wait_for_async_insert: 1,
 };
+/** Source maps above this go in with a plain insert (below ClickHouse's
+ * default async_insert_max_data_size of 10 MiB). */
+const ASYNC_INSERT_MAX_MAP_CHARS = 8 * 1024 * 1024;
 /** "YYYY-MM-DD hh:mm:ss.sss" (UTC) — the DateTime64 query-parameter form. */
 function chDateTime(date) {
     return date.toISOString().replace("T", " ").replace("Z", "");
@@ -474,7 +477,15 @@ export class ClickHouseStore {
         await this.ensureSchema();
         await this.getClient().insert({
             table: this.table("runtime_source_maps"), format: "JSONEachRow",
-            clickhouse_settings: INSERT_SETTINGS,
+            // One row of up to 32 MiB. Parallel parsing cuts input into
+            // 10 MiB chunks, refuses single JSON rows far past that, and gains
+            // nothing on one row. A map past the async-insert buffer (10 MiB
+            // by default) is inserted directly rather than buffered.
+            clickhouse_settings: {
+                ...INSERT_SETTINGS,
+                input_format_parallel_parsing: 0,
+                ...(sourceMap.map.length > ASYNC_INSERT_MAX_MAP_CHARS ? { async_insert: 0 } : {}),
+            },
             values: [{ org_id: ctx.orgId, repository_id: ctx.repositoryId, release: sourceMap.release,
                     filename: sourceMap.filename, map: sourceMap.map, debug_id: sourceMap.debugId,
                     content_hash: sourceMap.contentHash }],

package/dist/config.d.ts

@@ -55,9 +55,9 @@ export interface IngesterConfig {
     redactValuePatterns?: string[];
     redactKeyPatterns?: string[];
     /**
-     * In-memory budget (MiB, estimated decoded size) for parsed source maps
-     * used to symbolicate browser frames at ingest (SOURCE_MAP_CACHE_MB,
-     * default 64).
+     * In-memory budget (MiB, decoded size) for parsed source maps used to
+     * symbolicate browser frames at ingest (SOURCE_MAP_CACHE_MB, default 64).
+     * A map that needs more than half of it is used without being kept.
      */
     sourceMapCacheMb?: number;
 }

package/dist/normalize-browser.d.ts

@@ -64,10 +64,10 @@ export declare const browserPayloadSchema: z.ZodObject<{
         debugIds?: Record<string, unknown> | undefined;
         durationMs?: number | undefined;
         filename?: string | undefined;
-        id?: string | undefined;
-        name?: string | undefined;
-        line?: number | undefined;
         column?: number | undefined;
+        line?: number | undefined;
+        name?: string | undefined;
+        id?: string | undefined;
         context?: Record<string, unknown> | undefined;
         fingerprint?: string | string[] | undefined;
     }, {
@@ -83,10 +83,10 @@ export declare const browserPayloadSchema: z.ZodObject<{
         debugIds?: unknown;
         durationMs?: number | undefined;
         filename?: string | undefined;
-        id?: string | undefined;
-        name?: string | undefined;
-        line?: number | undefined;
         column?: number | undefined;
+        line?: number | undefined;
+        name?: string | undefined;
+        id?: string | undefined;
         context?: Record<string, unknown> | undefined;
         fingerprint?: unknown;
     }>, "many">;
@@ -107,10 +107,10 @@ export declare const browserPayloadSchema: z.ZodObject<{
         debugIds?: Record<string, unknown> | undefined;
         durationMs?: number | undefined;
         filename?: string | undefined;
-        id?: string | undefined;
-        name?: string | undefined;
-        line?: number | undefined;
         column?: number | undefined;
+        line?: number | undefined;
+        name?: string | undefined;
+        id?: string | undefined;
         context?: Record<string, unknown> | undefined;
         fingerprint?: string | string[] | undefined;
     }[];
@@ -134,10 +134,10 @@ export declare const browserPayloadSchema: z.ZodObject<{
         debugIds?: unknown;
         durationMs?: number | undefined;
         filename?: string | undefined;
-        id?: string | undefined;
-        name?: string | undefined;
-        line?: number | undefined;
         column?: number | undefined;
+        line?: number | undefined;
+        name?: string | undefined;
+        id?: string | undefined;
         context?: Record<string, unknown> | undefined;
         fingerprint?: unknown;
     }[];

package/dist/server.js

@@ -13,7 +13,7 @@ import { decodeMetricsRequest, decodeTraceRequest, decodeLogsRequest } from "./o
 import { normalizeLogs } from "./logs.js";
 import { decodeProfile } from "./profiles.js";
 import { normalizeMemoryMetrics, normalizePlatformEvent, platformEventSchema } from "./memory.js";
-import { validateSourceMap, validateSourceMapCheck } from "./source-maps.js";
+import { SOURCE_MAP_MAX_BODY_BYTES, validateSourceMap, validateSourceMapCheck } from "./source-maps.js";
 import { SinkForwarder } from "./sink.js";
 import { configureRedaction, scrubOccurrence } from "./redact.js";
 import { buildCompatReport, evaluateCompat, INGESTER_VERSION_HEADER, } from "./compat.js";
@@ -84,7 +84,40 @@ export function createIngesterApp(config) {
         next();
     });
     app.use(express.raw({ limit: "1mb", type: ["application/x-pprof"] }));
-    app.use("/v1/sourcemaps", express.json({ limit: "5mb" }));
+    // A check names at most 500 maps: well under 1 MB, whatever MAX_BODY_BYTES is.
+    app.use("/v1/sourcemaps/check", express.json({ limit: "1mb" }));
+    // Source map uploads (up to 32 MiB of JSON, usually gzipped) are routed
+    // before the small-body parsers below, and read their body only once the
+    // key is checked: an anonymous client can't make the ingester inflate and
+    // parse one. body-parser inflates gzip/deflate and applies the limit to
+    // the inflated bytes, so a small compressed body can't expand past it.
+    const sourceMapBody = express.json({ limit: SOURCE_MAP_MAX_BODY_BYTES });
+    app.post("/v1/sourcemaps", async (req, res, next) => {
+        // On failure the body is never read (Node discards it).
+        const ctx = await authenticate(req, res, "otlp");
+        if (!ctx)
+            return;
+        sourceMapBody(req, res, async (err) => {
+            if (err) {
+                next(err);
+                return;
+            }
+            const sourceMap = validateSourceMap(req.body);
+            if (!sourceMap) {
+                res.status(400).json({ error: "invalid source map" });
+                return;
+            }
+            // Idempotent: the same release + path replaces the earlier row
+            // (ReplacingMergeTree), so CI retries and re-runs are harmless.
+            try {
+                await store.insertSourceMap(ctx, sourceMap);
+                res.status(202).json({ accepted: true });
+            }
+            catch (storeErr) {
+                storageError(res, storeErr);
+            }
+        });
+    });
     app.use(express.json({
         limit: config.maxBodyBytes,
         type: ["application/json"],
@@ -341,25 +374,6 @@ export function createIngesterApp(config) {
             storageError(res, err);
         }
     });
-    app.post("/v1/sourcemaps", async (req, res) => {
-        const ctx = await authenticate(req, res, "otlp");
-        if (!ctx)
-            return;
-        const sourceMap = validateSourceMap(req.body);
-        if (!sourceMap) {
-            res.status(400).json({ error: "invalid source map" });
-            return;
-        }
-        // Idempotent: the same release + path replaces the earlier row
-        // (ReplacingMergeTree), so CI retries and re-runs are harmless.
-        try {
-            await store.insertSourceMap(ctx, sourceMap);
-            res.status(202).json({ accepted: true });
-        }
-        catch (err) {
-            storageError(res, err);
-        }
-    });
     /** Which of these maps does this tenant already have? Lets
      * `autter-runtime sourcemaps upload` skip unchanged maps (1.6.0+). */
     app.post("/v1/sourcemaps/check", async (req, res) => {

package/dist/source-map-mappings.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Position lookups in a source map's `mappings`, without the memory of a
+ * general-purpose decoder.
+ *
+ * @jridgewell/trace-mapping decodes `mappings` into one small array per
+ * segment: about 14 bytes of heap per byte of JSON (a 5 MB map takes 67 MB).
+ * Symbolication only needs "which original position is at or before this
+ * generated one", so a map that is kept in the cache is decoded into one
+ * Int32Array (5 ints per segment: about 3 bytes per byte of JSON), and a map
+ * too big to keep is not decoded at all: its frames are resolved in one
+ * streaming pass over the string.
+ *
+ * Lookup semantics match trace-mapping's `originalPositionFor` (greatest
+ * lower bound): the first segment that starts at the frame's column, else
+ * the last segment before it on the same line; a segment without a source
+ * maps to nothing.
+ */
+/** An original position. Lines and columns are 0-based; `name` is -1 when the segment has none. */
+export interface MappedSegment {
+    source: number;
+    line: number;
+    column: number;
+    name: number;
+}
+/** A 0-based generated (line, column). */
+export interface GeneratedPosition {
+    line: number;
+    column: number;
+}
+/**
+ * Walk a mappings-style string — `;` between generated lines, `,` between
+ * groups of base64 VLQ values — calling `visit(line, values, count)` with
+ * each group's raw (relative) values. `values` is reused between calls and
+ * holds the first 6; `count` is how many the group had. Throws on
+ * malformed VLQ. Also reads `x_autter_scopes` (source-map-scopes.ts).
+ */
+export declare function forEachVlqGroup(text: string, visit: (line: number, values: readonly number[], count: number) => void): void;
+/** Heap a DecodedMappings of `mappings` would take, without decoding it. */
+export declare function decodedMappingsBytes(mappings: string): number;
+export declare class DecodedMappings {
+    /** FIELDS ints per segment, each line's segments sorted by generated column. */
+    private readonly segments;
+    /** Index of each line's first segment; one extra entry closes the last line. */
+    private readonly lineStarts;
+    private constructor();
+    static decode(mappings: string): DecodedMappings;
+    get bytes(): number;
+    /** Generators almost always emit a line's segments in column order; sort the rare line that isn't (stable, as trace-mapping does). */
+    private sortLine;
+    /** The original position at a 0-based generated (line, column), or null. */
+    find(line: number, column: number): MappedSegment | null;
+}
+/**
+ * Resolve several positions in one pass over `mappings` without decoding
+ * it — for maps too big to keep. Same results as DecodedMappings.find.
+ */
+export declare function findInMappings(mappings: string, positions: readonly GeneratedPosition[]): Array<MappedSegment | null>;

package/dist/source-map-mappings.js

@@ -0,0 +1,245 @@
+/**
+ * Position lookups in a source map's `mappings`, without the memory of a
+ * general-purpose decoder.
+ *
+ * @jridgewell/trace-mapping decodes `mappings` into one small array per
+ * segment: about 14 bytes of heap per byte of JSON (a 5 MB map takes 67 MB).
+ * Symbolication only needs "which original position is at or before this
+ * generated one", so a map that is kept in the cache is decoded into one
+ * Int32Array (5 ints per segment: about 3 bytes per byte of JSON), and a map
+ * too big to keep is not decoded at all: its frames are resolved in one
+ * streaming pass over the string.
+ *
+ * Lookup semantics match trace-mapping's `originalPositionFor` (greatest
+ * lower bound): the first segment that starts at the frame's column, else
+ * the last segment before it on the same line; a segment without a source
+ * maps to nothing.
+ */
+/** generated column, source, original line, original column, name. */
+const FIELDS = 5;
+const NONE = -1;
+const BASE64 = new Int8Array(128).fill(-1);
+for (const [i, ch] of [..."ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"].entries()) {
+    BASE64[ch.charCodeAt(0)] = i;
+}
+/**
+ * Walk a mappings-style string — `;` between generated lines, `,` between
+ * groups of base64 VLQ values — calling `visit(line, values, count)` with
+ * each group's raw (relative) values. `values` is reused between calls and
+ * holds the first 6; `count` is how many the group had. Throws on
+ * malformed VLQ. Also reads `x_autter_scopes` (source-map-scopes.ts).
+ */
+export function forEachVlqGroup(text, visit) {
+    const values = [0, 0, 0, 0, 0, 0];
+    let line = 0;
+    let i = 0;
+    while (i < text.length) {
+        const ch = text.charCodeAt(i);
+        if (ch === 59 /* ; */) {
+            line++;
+            i++;
+            continue;
+        }
+        if (ch === 44 /* , */) {
+            i++;
+            continue;
+        }
+        let count = 0;
+        while (i < text.length) {
+            const next = text.charCodeAt(i);
+            if (next === 44 || next === 59)
+                break;
+            let value = 0;
+            let shift = 0;
+            let digit;
+            do {
+                const code = text.charCodeAt(i++);
+                digit = code < 128 ? BASE64[code] : -1;
+                if (digit < 0 || shift > 30)
+                    throw new Error("invalid VLQ");
+                value |= (digit & 31) << shift;
+                shift += 5;
+            } while (digit & 32);
+            if (count < values.length)
+                values[count] = value & 1 ? -(value >>> 1) : value >>> 1;
+            count++;
+        }
+        visit(line, values, count);
+    }
+}
+/**
+ * Walk every segment: `visit(line, generatedColumn, source, originalLine,
+ * originalColumn, name)`, with source and name -1 when absent. Throws on
+ * malformed VLQ.
+ */
+function forEachSegment(mappings, visit) {
+    let currentLine = 0;
+    let column = 0;
+    let source = 0;
+    let originalLine = 0;
+    let originalColumn = 0;
+    let name = 0;
+    forEachVlqGroup(mappings, (line, values, count) => {
+        // The generated column restarts on each line; the other fields don't.
+        if (line !== currentLine) {
+            currentLine = line;
+            column = 0;
+        }
+        column += values[0];
+        if (count >= 4) {
+            source += values[1];
+            originalLine += values[2];
+            originalColumn += values[3];
+        }
+        if (count >= 5)
+            name += values[4];
+        visit(line, column, count >= 4 ? source : NONE, originalLine, originalColumn, count >= 5 ? name : NONE);
+    });
+}
+/** Segments and generated lines in `mappings`, from one scan without decoding. */
+function countSegments(mappings) {
+    let segments = 0;
+    let lines = 1;
+    let inSegment = false;
+    for (let i = 0; i < mappings.length; i++) {
+        const ch = mappings.charCodeAt(i);
+        if (ch === 59) {
+            lines++;
+            inSegment = false;
+        }
+        else if (ch === 44) {
+            inSegment = false;
+        }
+        else if (!inSegment) {
+            segments++;
+            inSegment = true;
+        }
+    }
+    return { segments, lines };
+}
+/** Heap a DecodedMappings of `mappings` would take, without decoding it. */
+export function decodedMappingsBytes(mappings) {
+    const { segments, lines } = countSegments(mappings);
+    return segments * FIELDS * 4 + (lines + 1) * 4 + 64;
+}
+export class DecodedMappings {
+    segments;
+    lineStarts;
+    constructor(
+    /** FIELDS ints per segment, each line's segments sorted by generated column. */
+    segments, 
+    /** Index of each line's first segment; one extra entry closes the last line. */
+    lineStarts) {
+        this.segments = segments;
+        this.lineStarts = lineStarts;
+    }
+    static decode(mappings) {
+        const { segments: count, lines } = countSegments(mappings);
+        const segments = new Int32Array(count * FIELDS);
+        const lineStarts = new Int32Array(lines + 1);
+        let n = 0;
+        let currentLine = 0;
+        forEachSegment(mappings, (line, column, source, originalLine, originalColumn, name) => {
+            while (currentLine < line)
+                lineStarts[++currentLine] = n;
+            const at = n * FIELDS;
+            segments[at] = column;
+            segments[at + 1] = source;
+            segments[at + 2] = originalLine;
+            segments[at + 3] = originalColumn;
+            segments[at + 4] = name;
+            n++;
+        });
+        while (currentLine < lines)
+            lineStarts[++currentLine] = n;
+        const decoded = new DecodedMappings(segments, lineStarts);
+        for (let line = 0; line < lines; line++)
+            decoded.sortLine(line);
+        return decoded;
+    }
+    get bytes() {
+        return this.segments.byteLength + this.lineStarts.byteLength + 64;
+    }
+    /** Generators almost always emit a line's segments in column order; sort the rare line that isn't (stable, as trace-mapping does). */
+    sortLine(line) {
+        const start = this.lineStarts[line];
+        const end = this.lineStarts[line + 1];
+        const s = this.segments;
+        let sorted = true;
+        for (let i = start + 1; i < end && sorted; i++)
+            sorted = s[(i - 1) * FIELDS] <= s[i * FIELDS];
+        if (sorted)
+            return;
+        const rows = [];
+        for (let i = start; i < end; i++)
+            rows.push(Array.from(s.subarray(i * FIELDS, (i + 1) * FIELDS)));
+        rows.sort((a, b) => a[0] - b[0]);
+        rows.forEach((row, k) => s.set(row, (start + k) * FIELDS));
+    }
+    /** The original position at a 0-based generated (line, column), or null. */
+    find(line, column) {
+        if (line < 0 || line + 1 >= this.lineStarts.length)
+            return null;
+        const s = this.segments;
+        let lo = this.lineStarts[line];
+        let hi = this.lineStarts[line + 1] - 1;
+        let found = -1;
+        while (lo <= hi) {
+            const mid = (lo + hi) >> 1;
+            if (s[mid * FIELDS] <= column) {
+                found = mid;
+                lo = mid + 1;
+            }
+            else {
+                hi = mid - 1;
+            }
+        }
+        if (found < 0)
+            return null;
+        // Several segments at exactly this column: the first one (before it,
+        // the last one — as trace-mapping does).
+        if (s[found * FIELDS] === column) {
+            while (found > this.lineStarts[line] && s[(found - 1) * FIELDS] === column)
+                found--;
+        }
+        const at = found * FIELDS;
+        if (s[at + 1] === NONE)
+            return null;
+        return { source: s[at + 1], line: s[at + 2], column: s[at + 3], name: s[at + 4] };
+    }
+}
+/**
+ * Resolve several positions in one pass over `mappings` without decoding
+ * it — for maps too big to keep. Same results as DecodedMappings.find.
+ */
+export function findInMappings(mappings, positions) {
+    const byLine = new Map();
+    positions.forEach((position, index) => {
+        const list = byLine.get(position.line);
+        if (list)
+            list.push(index);
+        else
+            byLine.set(position.line, [index]);
+    });
+    const best = positions.map(() => null);
+    forEachSegment(mappings, (line, column, source, originalLine, originalColumn, name) => {
+        const wanted = byLine.get(line);
+        if (!wanted)
+            return;
+        for (const index of wanted) {
+            const target = positions[index].column;
+            const current = best[index];
+            // Greatest column at or before the position. On a tie the first
+            // segment wins at the position itself and the last one before it.
+            if (column > target)
+                continue;
+            if (current && (current.column > column || (current.column === column && column === target)))
+                continue;
+            best[index] = {
+                column,
+                segment: source === NONE ? null : { source, line: originalLine, column: originalColumn, name },
+            };
+        }
+    });
+    return best.map((found) => found?.segment ?? null);
+}

package/dist/source-map-scopes.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Function scopes uploaded with a source map (`x_autter_scopes`, written by
+ * `autter-runtime sourcemaps upload` in @autter/runtime-cli after 1.0.0):
+ * every function of the bundle as served, with its generated range and its
+ * ORIGINAL name. A frame is named after the innermost function that
+ * contains it — the name of the function it is in, as Sentry's
+ * js-source-scopes and PostHog cymbal's `token.scope()` do — instead of the
+ * name mapped at its caller's position, which is wrong whenever the call
+ * goes through a variable or a framework.
+ *
+ * Shape: `{ version: 1, names: (string | null)[], scopes: string }`.
+ * `scopes` is encoded like `mappings`: base64 VLQ, `;` between generated
+ * lines (the line each scope starts on), `,` between the scopes that start
+ * on one line, in start order (outer first on a tie). Each scope is 3 or 4
+ * values, 0-based and in UTF-16 columns:
+ *
+ *   1. start column, relative to the previous scope's start on the same
+ *      line (absolute for a line's first scope);
+ *   2. end line, relative to the start line;
+ *   3. end column (exclusive), relative to the start column when the scope
+ *      ends on its start line, else absolute;
+ *   4. the name, when the function has one: an index into the map's own
+ *      `names` followed by `x_autter_scopes.names`, relative to the last
+ *      name index written (starting from 0). A `null` entry in
+ *      `x_autter_scopes.names` is a name the CLI could not map back.
+ *
+ * A 3-value scope is anonymous. Anything else (wrong version, bad VLQ,
+ * out-of-range names, ranges that overlap without nesting) makes the whole
+ * field unusable, and the map is used as if it had none.
+ */
+export declare const SCOPES_KEY = "x_autter_scopes";
+export type ScopeName = 
+/** In a function with a known original name. */
+{
+    kind: "named";
+    name: string;
+}
+/** In an anonymous function, or in no function at all (top-level code). */
+ | {
+    kind: "anonymous";
+}
+/** In a named function whose original name is unknown. */
+ | {
+    kind: "unknown";
+};
+export declare class ScopeIndex {
+    /** STRIDE ints per scope, sorted by start (outer first on a tie). */
+    private readonly table;
+    /** The map's own `names`, then `x_autter_scopes.names`. */
+    private readonly mapNames;
+    private readonly extraNames;
+    private constructor();
+    /** Number of function scopes. */
+    get size(): number;
+    /** Estimated memory, for the source map cache's byte budget (the map's
+     * own `names` are counted with the map). */
+    get bytes(): number;
+    /**
+     * The parsed `x_autter_scopes` value, or null when it is absent or
+     * malformed. `mapNames` is the map's own `names` array, which scope name
+     * indexes continue.
+     */
+    static from(raw: unknown, mapNames?: readonly unknown[]): ScopeIndex | null;
+    private nameOf;
+    /**
+     * The name for a frame at a 0-based generated (line, column): the
+     * innermost function containing it. Outside every function (top-level
+     * code) it is anonymous.
+     */
+    nameAt(line: number, column: number): ScopeName;
+}

package/dist/source-map-scopes.js

@@ -0,0 +1,190 @@
+import { forEachVlqGroup } from "./source-map-mappings.js";
+/**
+ * Function scopes uploaded with a source map (`x_autter_scopes`, written by
+ * `autter-runtime sourcemaps upload` in @autter/runtime-cli after 1.0.0):
+ * every function of the bundle as served, with its generated range and its
+ * ORIGINAL name. A frame is named after the innermost function that
+ * contains it — the name of the function it is in, as Sentry's
+ * js-source-scopes and PostHog cymbal's `token.scope()` do — instead of the
+ * name mapped at its caller's position, which is wrong whenever the call
+ * goes through a variable or a framework.
+ *
+ * Shape: `{ version: 1, names: (string | null)[], scopes: string }`.
+ * `scopes` is encoded like `mappings`: base64 VLQ, `;` between generated
+ * lines (the line each scope starts on), `,` between the scopes that start
+ * on one line, in start order (outer first on a tie). Each scope is 3 or 4
+ * values, 0-based and in UTF-16 columns:
+ *
+ *   1. start column, relative to the previous scope's start on the same
+ *      line (absolute for a line's first scope);
+ *   2. end line, relative to the start line;
+ *   3. end column (exclusive), relative to the start column when the scope
+ *      ends on its start line, else absolute;
+ *   4. the name, when the function has one: an index into the map's own
+ *      `names` followed by `x_autter_scopes.names`, relative to the last
+ *      name index written (starting from 0). A `null` entry in
+ *      `x_autter_scopes.names` is a name the CLI could not map back.
+ *
+ * A 3-value scope is anonymous. Anything else (wrong version, bad VLQ,
+ * out-of-range names, ranges that overlap without nesting) makes the whole
+ * field unusable, and the map is used as if it had none.
+ */
+export const SCOPES_KEY = "x_autter_scopes";
+const ANONYMOUS = -1;
+/** startLine, startCol, endLine, endCol, nameIndex, parent. */
+const STRIDE = 6;
+const MAX_POSITION = 0x7fffffff;
+const ANONYMOUS_SCOPE = { kind: "anonymous" };
+const UNKNOWN_SCOPE = { kind: "unknown" };
+class MalformedScopes extends Error {
+}
+/** a < b for (line, column) pairs. */
+function before(lineA, colA, lineB, colB) {
+    return lineA < lineB || (lineA === lineB && colA < colB);
+}
+/** Decode the `scopes` string into [startLine, startCol, endLine, endCol, nameIndex] rows. */
+function decodeScopes(text, isName) {
+    const rows = [];
+    let currentLine = 0;
+    let startCol = 0;
+    let name = 0;
+    forEachVlqGroup(text, (line, values, count) => {
+        if (count !== 3 && count !== 4)
+            throw new MalformedScopes("a scope has 3 or 4 values");
+        if (line !== currentLine) {
+            currentLine = line;
+            startCol = 0;
+        }
+        startCol += values[0];
+        const endLine = line + values[1];
+        const endCol = values[1] === 0 ? startCol + values[2] : values[2];
+        let nameIndex = ANONYMOUS;
+        if (count === 4) {
+            name += values[3];
+            if (!isName(name))
+                throw new MalformedScopes("name out of range");
+            nameIndex = name;
+        }
+        if (startCol < 0 || values[1] < 0 || endCol < 0 || endLine > MAX_POSITION || Math.max(startCol, endCol) > MAX_POSITION) {
+            throw new MalformedScopes("position out of range");
+        }
+        // Non-empty: a function is at least `()=>0`.
+        if (!before(line, startCol, endLine, endCol))
+            throw new MalformedScopes("empty scope");
+        rows.push([line, startCol, endLine, endCol, nameIndex]);
+    });
+    return rows;
+}
+export class ScopeIndex {
+    table;
+    mapNames;
+    extraNames;
+    constructor(
+    /** STRIDE ints per scope, sorted by start (outer first on a tie). */
+    table, 
+    /** The map's own `names`, then `x_autter_scopes.names`. */
+    mapNames, extraNames) {
+        this.table = table;
+        this.mapNames = mapNames;
+        this.extraNames = extraNames;
+    }
+    /** Number of function scopes. */
+    get size() {
+        return this.table.length / STRIDE;
+    }
+    /** Estimated memory, for the source map cache's byte budget (the map's
+     * own `names` are counted with the map). */
+    get bytes() {
+        let bytes = this.table.byteLength + 64;
+        for (const name of this.extraNames)
+            bytes += 2 * (name?.length ?? 0) + 32;
+        return bytes;
+    }
+    /**
+     * The parsed `x_autter_scopes` value, or null when it is absent or
+     * malformed. `mapNames` is the map's own `names` array, which scope name
+     * indexes continue.
+     */
+    static from(raw, mapNames = []) {
+        if (!raw || typeof raw !== "object" || Array.isArray(raw))
+            return null;
+        const { version, names, scopes } = raw;
+        if (version !== 1 || !Array.isArray(names) || typeof scopes !== "string")
+            return null;
+        if (!names.every((name) => typeof name === "string" || name === null))
+            return null;
+        const extraNames = names;
+        const isName = (index) => index >= 0 &&
+            (index < mapNames.length
+                ? typeof mapNames[index] === "string"
+                : index - mapNames.length < extraNames.length);
+        let entries;
+        try {
+            entries = decodeScopes(scopes, isName);
+        }
+        catch {
+            return null;
+        }
+        // Encoded in order already; sort anyway so a hand-written field works too.
+        entries.sort((a, b) => a[0] - b[0] || a[1] - b[1] || b[2] - a[2] || b[3] - a[3]);
+        const table = new Int32Array(entries.length * STRIDE);
+        // Open scopes, outermost first: each new scope either nests in the
+        // innermost one still open or starts after it has ended.
+        const open = [];
+        for (let i = 0; i < entries.length; i++) {
+            const [startLine, startCol, endLine, endCol, nameIndex] = entries[i];
+            while (open.length > 0) {
+                const top = open[open.length - 1] * STRIDE;
+                if (before(startLine, startCol, table[top + 2], table[top + 3]))
+                    break;
+                open.pop();
+            }
+            const parent = open.length > 0 ? open[open.length - 1] : -1;
+            if (parent >= 0 && before(table[parent * STRIDE + 2], table[parent * STRIDE + 3], endLine, endCol)) {
+                return null; // overlaps its parent without nesting in it
+            }
+            const at = i * STRIDE;
+            table[at] = startLine;
+            table[at + 1] = startCol;
+            table[at + 2] = endLine;
+            table[at + 3] = endCol;
+            table[at + 4] = nameIndex;
+            table[at + 5] = parent;
+            open.push(i);
+        }
+        return new ScopeIndex(table, mapNames, extraNames);
+    }
+    nameOf(index) {
+        if (index === ANONYMOUS)
+            return ANONYMOUS_SCOPE;
+        const name = index < this.mapNames.length ? this.mapNames[index] : this.extraNames[index - this.mapNames.length];
+        return typeof name === "string" ? { kind: "named", name } : UNKNOWN_SCOPE;
+    }
+    /**
+     * The name for a frame at a 0-based generated (line, column): the
+     * innermost function containing it. Outside every function (top-level
+     * code) it is anonymous.
+     */
+    nameAt(line, column) {
+        const t = this.table;
+        // Last scope that starts at or before the position…
+        let lo = 0;
+        let hi = this.size - 1;
+        let found = -1;
+        while (lo <= hi) {
+            const mid = (lo + hi) >> 1;
+            if (before(line, column, t[mid * STRIDE], t[mid * STRIDE + 1]))
+                hi = mid - 1;
+            else {
+                found = mid;
+                lo = mid + 1;
+            }
+        }
+        // …or, when it ended before the position, its closest ancestor that hasn't.
+        for (let i = found; i >= 0; i = t[i * STRIDE + 5]) {
+            if (before(line, column, t[i * STRIDE + 2], t[i * STRIDE + 3]))
+                return this.nameOf(t[i * STRIDE + 4]);
+        }
+        return ANONYMOUS_SCOPE;
+    }
+}

package/dist/source-maps.d.ts

@@ -1,5 +1,14 @@
-/** Largest stored map (after `sourcesContent` is removed), in characters. */
+/**
+ * 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.
+ */
 export declare const SOURCE_MAP_MAX_CHARS: number;
+/** `/v1/sourcemaps` body limit, counted after a gzip or deflate body is
+ * inflated: the largest map plus room for the rest of the request. */
+export declare const SOURCE_MAP_MAX_BODY_BYTES: number;
 /** A debug id: 8-4-4-4-12 lowercase hex. Written by `autter-runtime
  * sourcemaps inject`, and by Rollup, Turbopack, esbuild and Sentry tooling. */
 export declare const DEBUG_ID_RE: RegExp;

package/dist/source-maps.js

@@ -1,7 +1,16 @@
 import { createHash } from "node:crypto";
 import { scrubText } from "./redact.js";
-/** Largest stored map (after `sourcesContent` is removed), in characters. */
-export const SOURCE_MAP_MAX_CHARS = 5 * 1024 * 1024;
+/**
+ * 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.
+ */
+export const SOURCE_MAP_MAX_CHARS = 32 * 1024 * 1024;
+/** `/v1/sourcemaps` body limit, counted after a gzip or deflate body is
+ * inflated: the largest map plus room for the rest of the request. */
+export const SOURCE_MAP_MAX_BODY_BYTES = SOURCE_MAP_MAX_CHARS + 1024 * 1024;
 /** Bundles a map can be uploaded for: `.js`, `.mjs` and `.cjs` (1.6.0+). */
 const BUNDLE_PATH_RE = /\.[cm]?js$/;
 /** A debug id: 8-4-4-4-12 lowercase hex. Written by `autter-runtime
@@ -83,7 +92,10 @@ 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.
+    // 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)

package/dist/symbolicate.d.ts

@@ -1,4 +1,6 @@
 import { TraceMap } from "@jridgewell/trace-mapping";
+import { type GeneratedPosition, type MappedSegment } from "./source-map-mappings.js";
+import { ScopeIndex } from "./source-map-scopes.js";
 import type { SourceMapKey } from "./source-maps-lookup.js";
 import type { StackFrame } from "./types.js";
 /**
@@ -7,11 +9,17 @@ import type { StackFrame } from "./types.js";
  * fingerprinted, so `frames-v3` hashes `checkout.tsx`, not
  * `index-5f3a9c1e.js` — and an issue survives deploys and preview domains.
  *
- * - Function names come from the map's `names`: the name mapped at the
- *   CALLER's position is the callee's original name (the call site names
- *   what it calls). Without one, a resolved frame keeps its parsed name
- *   only when that is not an obviously mangled one (≤ 2 characters), since
- *   a mangled name changes on every build.
+ * - Function names: when the map carries function scopes
+ *   (`x_autter_scopes`, uploaded by @autter/runtime-cli after 1.0.0), a
+ *   frame is named after the innermost function containing it, with that
+ *   function's original name (null in an anonymous function or top-level
+ *   code) — see source-map-scopes.ts. Maps without scopes keep the earlier
+ *   rule: the name mapped at the CALLER's position is the callee's original
+ *   name; without one, a resolved frame keeps its parsed name only when
+ *   that is not an obviously mangled one (≤ 2 characters), since a mangled
+ *   name changes on every build. That rule is wrong for calls through a
+ *   variable (`const run = actions.captured; run()` names the frame `run`)
+ *   and for handlers a framework calls, which is why scopes exist.
  * - Sources the map lists in `ignoreList` / `x_google_ignoreList` are not
  *   in-app; a resolved path under node_modules/ etc. is not in-app either.
  * - Context lines only when the map carries `sourcesContent` (the upload
@@ -19,7 +27,10 @@ import type { StackFrame } from "./types.js";
  * - Never fails ingest: any error leaves the frame as parsed.
  *
  * Parsed maps are cached per (org, repository, release, file) — or per debug
- * id — in a byte-bounded LRU, so a busy issue never refetches its map.
+ * id — in a byte-bounded LRU, so a busy issue never refetches its map. A map
+ * that would take more than half of that budget is used for its lookup and
+ * not kept (source-map-mappings.ts reads it without decoding it), so one huge
+ * vendor chunk cannot flush every other map.
  */
 export type MapFetcher = (key: SourceMapKey) => Promise<string | null>;
 export interface SymbolicationScope {
@@ -32,7 +43,8 @@ export interface SymbolicationScope {
 /** Path-only form of a script URL — the key uploads are stored under. */
 export declare function scriptPath(filename: string): string | null;
 export interface SourceMapCacheOptions {
-    /** Budget for the estimated in-memory size of parsed maps (default 64 MiB). */
+    /** Budget for the estimated in-memory size of parsed maps (default 64 MiB).
+     * A map that would take more than half of it is not cached. */
     maxBytes?: number;
     maxEntries?: number;
     /** How long a found map is reused (default 1 h). */
@@ -43,6 +55,19 @@ export interface SourceMapCacheOptions {
     errorTtlMs?: number;
     now?: () => number;
 }
+/** A parsed map: its metadata, its function scopes, and position lookups. */
+export interface LoadedSourceMap {
+    /** Sources, names, ignore list and sourcesContent. Its own `mappings`
+     * are left empty: positions go through `lookup`. */
+    map: TraceMap;
+    scopes: ScopeIndex | null;
+    /** Original positions for 0-based generated positions (one call per stack). */
+    lookup(positions: readonly GeneratedPosition[]): Array<MappedSegment | null>;
+    /** Estimated heap: decoded mappings (when decoded), strings and scopes. */
+    bytes: number;
+    /** False when the map was too big to keep, so its mappings were not decoded. */
+    cacheable: boolean;
+}
 export declare class SourceMapCache {
     private readonly entries;
     private readonly inFlight;
@@ -55,15 +80,28 @@ export declare class SourceMapCache {
     private readonly now;
     /** Fetches made (cache misses) — for tests and /healthz-style debugging. */
     fetches: number;
+    /** Maps used without being cached because they were too big to keep. */
+    bypassed: number;
     constructor(options?: SourceMapCacheOptions);
     static keyOf(key: SourceMapKey): string;
     get size(): number;
+    /** Estimated bytes of the cached maps (what `maxBytes` bounds). */
+    get bytes(): number;
     /** The parsed map for `key` (null when none), fetching at most once at a time. */
-    get(key: SourceMapKey, fetchMap: MapFetcher): Promise<TraceMap | null>;
+    get(key: SourceMapKey, fetchMap: MapFetcher): Promise<LoadedSourceMap | null>;
     private load;
     private store;
     private remove;
 }
+/**
+ * Parse a stored map once: metadata, scopes (null when absent or malformed
+ * — a bad scope field never loses the map) and position lookups. When the
+ * estimated heap is at most `maxDecodedBytes`, the mappings are decoded
+ * once into a compact table; otherwise they are left encoded and each
+ * lookup reads them in one pass (`cacheable: false`). Throws when the map
+ * itself is unusable.
+ */
+export declare function parseSourceMap(json: string, maxDecodedBytes?: number): LoadedSourceMap;
 export declare class Symbolicator {
     private readonly fetchMap;
     readonly cache: SourceMapCache;

package/dist/symbolicate.js

@@ -1,4 +1,6 @@
-import { isIgnored, originalPositionFor, sourceContentFor, TraceMap, } from "@jridgewell/trace-mapping";
+import { isIgnored, sourceContentFor, TraceMap, } from "@jridgewell/trace-mapping";
+import { DecodedMappings, decodedMappingsBytes, findInMappings, } from "./source-map-mappings.js";
+import { SCOPES_KEY, ScopeIndex } from "./source-map-scopes.js";
 import { isInAppPath, stripQueryAndHash } from "./stack-frames.js";
 const JS_FILE_RE = /\.[cm]?js$/i;
 const MAX_CONTEXT_CHARS = 300;
@@ -13,10 +15,11 @@ export function scriptPath(filename) {
     }
 }
 /**
- * Decoded mappings take several times the JSON's size; the budget counts an
- * estimate so a handful of large bundles cannot exhaust a small container.
+ * The largest share of the budget one map may take. A bigger one is used
+ * for its lookup and dropped: keeping it would evict most other maps, and
+ * every event in those files would then refetch theirs.
  */
-const DECODED_WEIGHT_FACTOR = 8;
+const MAX_SHARE_OF_BUDGET = 0.5;
 export class SourceMapCache {
     entries = new Map();
     inFlight = new Map();
@@ -29,6 +32,8 @@ export class SourceMapCache {
     now;
     /** Fetches made (cache misses) — for tests and /healthz-style debugging. */
     fetches = 0;
+    /** Maps used without being cached because they were too big to keep. */
+    bypassed = 0;
     constructor(options = {}) {
         this.maxBytes = options.maxBytes ?? 64 * 1024 * 1024;
         this.maxEntries = options.maxEntries ?? 500;
@@ -46,6 +51,10 @@ export class SourceMapCache {
     get size() {
         return this.entries.size;
     }
+    /** Estimated bytes of the cached maps (what `maxBytes` bounds). */
+    get bytes() {
+        return this.weight;
+    }
     /** The parsed map for `key` (null when none), fetching at most once at a time. */
     async get(key, fetchMap) {
         const id = SourceMapCache.keyOf(key);
@@ -81,17 +90,20 @@ export class SourceMapCache {
             this.store(id, null, 0, this.missTtlMs);
             return null;
         }
-        let map;
+        let loaded;
         try {
-            map = new TraceMap(json);
+            loaded = parseSourceMap(json, this.maxBytes * MAX_SHARE_OF_BUDGET);
         }
         catch {
             // A malformed upload is a miss until it is replaced.
             this.store(id, null, 0, this.missTtlMs);
             return null;
         }
-        this.store(id, map, json.length * DECODED_WEIGHT_FACTOR, this.hitTtlMs);
-        return map;
+        if (loaded.cacheable)
+            this.store(id, loaded, loaded.bytes, this.hitTtlMs);
+        else
+            this.bypassed += 1;
+        return loaded;
     }
     store(id, map, weight, ttlMs) {
         // A map bigger than the whole budget serves this lookup but is not kept:
@@ -115,6 +127,61 @@ export class SourceMapCache {
         this.weight -= entry.weight;
     }
 }
+/** Rough heap of a list of strings (V8 strings plus array slots). */
+function stringsBytes(list) {
+    if (!Array.isArray(list))
+        return 0;
+    let bytes = 16;
+    for (const item of list)
+        bytes += 8 + (typeof item === "string" ? 2 * item.length + 24 : 0);
+    return bytes;
+}
+/**
+ * Parse a stored map once: metadata, scopes (null when absent or malformed
+ * — a bad scope field never loses the map) and position lookups. When the
+ * estimated heap is at most `maxDecodedBytes`, the mappings are decoded
+ * once into a compact table; otherwise they are left encoded and each
+ * lookup reads them in one pass (`cacheable: false`). Throws when the map
+ * itself is unusable.
+ */
+export function parseSourceMap(json, maxDecodedBytes = Number.POSITIVE_INFINITY) {
+    const raw = JSON.parse(json);
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        throw new Error("not a source map");
+    const fields = raw;
+    const { mappings } = fields;
+    if (typeof mappings !== "string")
+        throw new Error("no mappings");
+    // TraceMap copies only the standard fields, but given an object that has
+    // its private `_decodedMemo` it would return that object as is. It gets
+    // no mappings: decoding them is this module's job.
+    delete fields._decodedMemo;
+    const map = new TraceMap({ ...fields, mappings: "" });
+    let scopes = null;
+    try {
+        scopes = ScopeIndex.from(fields[SCOPES_KEY], map.names);
+    }
+    catch {
+        scopes = null;
+    }
+    const bytes = decodedMappingsBytes(mappings) +
+        stringsBytes(map.names) +
+        stringsBytes(map.sources) +
+        stringsBytes(map.resolvedSources) +
+        stringsBytes(map.sourcesContent) +
+        (scopes?.bytes ?? 0);
+    if (bytes <= maxDecodedBytes) {
+        const decoded = DecodedMappings.decode(mappings);
+        return {
+            map,
+            scopes,
+            bytes,
+            cacheable: true,
+            lookup: (positions) => positions.map((position) => decoded.find(position.line, position.column)),
+        };
+    }
+    return { map, scopes, bytes, cacheable: false, lookup: (positions) => findInMappings(mappings, positions) };
+}
 // ── Resolution ────────────────────────────────────────────────────────────
 /** A name a minifier evidently produced ("a", "Xe", "Object.t"). */
 function looksMangled(name) {
@@ -201,24 +268,20 @@ export class Symbolicator {
         if (!keys.some(Boolean))
             return frames;
         const maps = await Promise.all(keys.map((key) => (key ? this.cache.get(key, this.fetchMap) : Promise.resolve(null))));
-        const resolutions = frames.map((frame, i) => {
-            const map = maps[i];
-            if (!map)
-                return null;
-            try {
-                return resolveFrame(map, frame);
-            }
-            catch {
-                return null;
-            }
-        });
+        const resolutions = resolveFrames(frames, maps);
         if (!resolutions.some(Boolean))
             return frames;
         return frames.map((frame, i) => {
             const resolution = resolutions[i];
             if (!resolution)
                 return frame;
-            // Innermost first: the caller is the next frame.
+            const { scope } = resolution;
+            if (scope?.kind === "named")
+                return { ...resolution.frame, function: scope.name };
+            if (scope?.kind === "anonymous")
+                return { ...resolution.frame, function: null };
+            // No scopes (an older upload), or a function whose name the CLI
+            // could not map: innermost first, so the caller is the next frame.
             const callerName = resolutions[i + 1]?.nameHere ?? null;
             const parsed = frame.function;
             const name = callerName ?? (parsed && !looksMangled(parsed) ? parsed : null);
@@ -226,32 +289,75 @@ export class Symbolicator {
         });
     }
 }
-function resolveFrame(map, frame) {
-    const position = originalPositionFor(map, {
-        line: frame.lineno,
-        // Stack columns are 1-based, source map columns 0-based.
-        column: Math.max(0, (frame.colno ?? 1) - 1),
+/** A frame's 0-based generated position (stack lines and columns are 1-based). */
+function generatedPosition(frame) {
+    return { line: frame.lineno - 1, column: Math.max(0, (frame.colno ?? 1) - 1) };
+}
+/** Resolve every frame that has a map, with one lookup per map: a map too
+ * big to keep is read in a single pass for the whole stack. */
+function resolveFrames(frames, maps) {
+    const resolutions = frames.map(() => null);
+    const byMap = new Map();
+    maps.forEach((loaded, index) => {
+        if (!loaded)
+            return;
+        const indexes = byMap.get(loaded);
+        if (indexes)
+            indexes.push(index);
+        else
+            byMap.set(loaded, [index]);
     });
-    if (!position.source || position.line == null)
+    for (const [loaded, indexes] of byMap) {
+        const positions = indexes.map((index) => generatedPosition(frames[index]));
+        let segments;
+        try {
+            segments = loaded.lookup(positions);
+        }
+        catch {
+            continue;
+        }
+        indexes.forEach((frameIndex, k) => {
+            try {
+                resolutions[frameIndex] = resolveFrame(loaded, frames[frameIndex], positions[k], segments[k] ?? null);
+            }
+            catch {
+                resolutions[frameIndex] = null;
+            }
+        });
+    }
+    return resolutions;
+}
+function resolveFrame(loaded, frame, position, segment) {
+    const { map } = loaded;
+    if (!segment)
+        return null;
+    const source = map.resolvedSources[segment.source];
+    if (!source)
         return null;
-    const filename = stripQueryAndHash(position.source);
+    const filename = stripQueryAndHash(source);
     const ignored = (() => {
         try {
-            return isIgnored(map, position.source);
+            return isIgnored(map, source);
         }
         catch {
             return false;
         }
     })();
+    const line = segment.line + 1;
     const resolved = {
         function: frame.function,
         module: null,
         filename,
-        lineno: position.line,
-        colno: position.column == null ? null : position.column + 1,
+        lineno: line,
+        colno: segment.column + 1,
         inApp: !ignored && isInAppPath(filename),
         resolved: true,
-        ...contextFor(map, position.source, position.line),
+        ...contextFor(map, source, line),
+    };
+    const name = segment.name >= 0 ? map.names[segment.name] : undefined;
+    return {
+        frame: resolved,
+        nameHere: typeof name === "string" ? name : null,
+        scope: loaded.scopes ? loaded.scopes.nameAt(position.line, position.column) : null,
     };
-    return { frame: resolved, nameHere: position.name ?? null };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@autter/otlp-ingester",
-	"version": "1.6.0",
+	"version": "1.6.1",
 	"description": "Self-hostable OTLP + browser-error ingest service for Autter Runtime: normalises telemetry into a per-repo ClickHouse data model",
 	"license": "MIT",
 	"type": "module",