@autter/otlp-ingester 1.6.0 → 1.7.0

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-lookup.d.ts

@@ -21,9 +21,12 @@ export declare function lookupSourceMap(client: ClickHouseClient, database: stri
  */
 export declare const SOURCE_MAP_FRESH_DAYS = 7;
 /**
- * Which check entries the tenant already has: same release, path, debug id
- * and content hash, uploaded in the last SOURCE_MAP_FRESH_DAYS. Returns the
- * indexes of `check.entries` that need no upload.
+ * Which check entries the tenant already has. An entry with a hash: same
+ * release, path, debug id and content hash, uploaded in the last
+ * SOURCE_MAP_FRESH_DAYS (the upload skips those). An entry with only a
+ * debug id: any stored map with that id, whatever its release and path —
+ * exactly what lookupSourceMap would find for a stack from that bundle.
+ * Returns the indexes of `check.entries` that are present.
  */
 export declare function presentSourceMaps(client: ClickHouseClient, database: string, tenant: {
     orgId: string;

package/dist/source-maps-lookup.js

@@ -34,13 +34,41 @@ export async function lookupSourceMap(client, database, key) {
  */
 export const SOURCE_MAP_FRESH_DAYS = 7;
 /**
- * Which check entries the tenant already has: same release, path, debug id
- * and content hash, uploaded in the last SOURCE_MAP_FRESH_DAYS. Returns the
- * indexes of `check.entries` that need no upload.
+ * Which check entries the tenant already has. An entry with a hash: same
+ * release, path, debug id and content hash, uploaded in the last
+ * SOURCE_MAP_FRESH_DAYS (the upload skips those). An entry with only a
+ * debug id: any stored map with that id, whatever its release and path —
+ * exactly what lookupSourceMap would find for a stack from that bundle.
+ * Returns the indexes of `check.entries` that are present.
  */
 export async function presentSourceMaps(client, database, tenant, check) {
-    if (check.entries.length === 0)
-        return [];
+    const hashed = check.entries.some((entry) => entry.hash);
+    const byId = check.entries.filter((entry) => !entry.hash).map((entry) => entry.debugId);
+    const [withHash, ids] = await Promise.all([
+        hashed ? presentByHash(client, database, tenant, check) : new Set(),
+        byId.length ? presentDebugIds(client, database, tenant, byId) : new Set(),
+    ]);
+    const present = [];
+    check.entries.forEach((entry, index) => {
+        const found = entry.hash
+            ? withHash.has(`${entry.filename}\u0000${entry.debugId}\u0000${entry.hash}`)
+            : ids.has(entry.debugId);
+        if (found)
+            present.push(index);
+    });
+    return present;
+}
+async function presentDebugIds(client, database, tenant, debugIds) {
+    const rows = await client.query({
+        query: `SELECT DISTINCT debug_id FROM ${database}.runtime_source_maps
+			WHERE org_id = {org:String} AND repository_id = {repo:String}
+				AND has({debugIds:Array(String)}, debug_id)`,
+        query_params: { org: tenant.orgId, repo: tenant.repositoryId, debugIds: [...new Set(debugIds)] },
+        format: "JSONEachRow",
+    });
+    return new Set((await rows.json()).map((row) => row.debug_id));
+}
+async function presentByHash(client, database, tenant, check) {
     const rows = await client.query({
         query: `SELECT DISTINCT filename, debug_id, content_hash FROM ${database}.runtime_source_maps
 			WHERE org_id = {org:String} AND repository_id = {repo:String} AND release = {release:String}
@@ -50,15 +78,9 @@ export async function presentSourceMaps(client, database, tenant, check) {
             org: tenant.orgId,
             repo: tenant.repositoryId,
             release: check.release,
-            hashes: [...new Set(check.entries.map((entry) => entry.hash))],
+            hashes: [...new Set(check.entries.filter((entry) => entry.hash).map((entry) => entry.hash))],
         },
         format: "JSONEachRow",
     });
-    const stored = new Set((await rows.json()).map((row) => `${row.filename}\u0000${row.debug_id}\u0000${row.content_hash}`));
-    const present = [];
-    check.entries.forEach((entry, index) => {
-        if (stored.has(`${entry.filename}\u0000${entry.debugId}\u0000${entry.hash}`))
-            present.push(index);
-    });
-    return present;
+    return new Set((await rows.json()).map((row) => `${row.filename}\u0000${row.debug_id}\u0000${row.content_hash}`));
 }

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;
@@ -40,6 +49,7 @@ export declare function validateSourceMap(body: unknown): ValidSourceMap | null;
 export interface SourceMapCheckEntry {
     filename: string;
     debugId: string;
+    /** sha256 of the stored map, or "" for a check by debug id alone (1.7.0+). */
     hash: string;
 }
 export interface SourceMapCheck {
@@ -50,9 +60,12 @@ export interface SourceMapCheck {
 export declare const SOURCE_MAP_CHECK_MAX = 500;
 /**
  * Validate a `/v1/sourcemaps/check` request:
- * `{ release, files: [{ filename, debugId?, hash }] }` (≤ 500 files). The
+ * `{ release, files: [{ filename, debugId?, hash? }] }` (≤ 500 files). The
  * filenames and debug ids are normalised exactly as an upload would store
- * them. Null when invalid.
+ * them. Each file needs a hash (is this exact map stored? — what `upload`
+ * asks to skip maps) or, from 1.7.0, a debug id alone (is any map stored
+ * for this bundle? — what `sourcemaps verify` asks after the maps were
+ * deleted). Null when invalid.
  */
 export declare function validateSourceMapCheck(body: unknown): SourceMapCheck | null;
 /** Most scripts one browser event may name in `debugIds`. */