@autter/otlp-ingester 1.10.0 → 1.11.0

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;
+}

package/dist/symbolicate.d.ts

@@ -4,10 +4,19 @@ import { ScopeIndex } from "./source-map-scopes.js";
 import type { SourceMapKey } from "./source-maps-lookup.js";
 import type { StackFrame } from "./types.js";
 /**
- * Symbolication at ingest: minified browser frames are resolved through the
- * source maps uploaded for the release (`/v1/sourcemaps`) BEFORE they are
- * fingerprinted, so `frames-v3` hashes `checkout.tsx`, not
- * `index-5f3a9c1e.js` — and an issue survives deploys and preview domains.
+ * Symbolication at ingest: minified browser frames, and bundled Node and
+ * edge frames (RF-05), are resolved through the source maps uploaded for
+ * the release (`/v1/sourcemaps`) BEFORE they are fingerprinted, so
+ * `frames-v3` hashes `checkout.tsx`, not `index-5f3a9c1e.js` — and an issue
+ * survives deploys and preview domains.
+ *
+ * - Browser frames find their map by debug id, else by release + the
+ *   script's path. Server frames (`server: true`) by debug id (server SDKs
+ *   send `autter.debug_ids`), else by the release's map stored
+ *   under the longest suffix of the path the process ran the bundle from
+ *   (source-maps-lookup.ts): the upload knows `/server.js`, the stack says
+ *   `/app/dist/server.js`. Only in-app server frames are looked up — a
+ *   `node_modules/` or `node:` frame never belongs to an uploaded bundle.
  *
  * - Function names: when the map carries function scopes
  *   (`x_autter_scopes`, uploaded by @autter/runtime-cli after 1.0.0), a
@@ -22,24 +31,38 @@ import type { StackFrame } from "./types.js";
  *   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
- *   strips it today, so there are none for now).
+ * - Context lines (RF-05): an in-app resolved frame gets its original line
+ *   and up to CONTEXT_LINES lines before and after it, each cut to 300
+ *   characters and scrubbed like the stack, when the map carries the
+ *   source's `sourcesContent` (kept at upload for in-app sources,
+ *   source-maps.ts). Dependency frames get none.
  * - 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. 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.
+ * vendor chunk cannot flush every other map. A map's source contents are
+ * never part of its entry (it caches exactly as a map without them would):
+ * they sit in a separate store, one file per entry, bounded the same way and
+ * dropped with the map.
  */
 export type MapFetcher = (key: SourceMapKey) => Promise<string | null>;
 export interface SymbolicationScope {
     orgId: string;
     repositoryId: string;
     release: string | null;
-    /** Script URL → debug id (EI-13), when the browser sent them. */
+    /** Script URL (or, on a server, script path) → debug id (EI-13), when the SDK sent them. */
     debugIds?: Record<string, string> | null;
+    /**
+     * A Node or edge stack (RF-05): only in-app frames are looked up, their
+     * paths are normalised (serverScriptPath), and without a debug id the
+     * release's map is found by path suffix.
+     */
+    server?: boolean;
 }
+/** Lines kept before and after an in-app frame's own line (RF-05). */
+export declare const CONTEXT_LINES = 5;
 /**
  * In-app browser frames a source map could resolve, counted after
  * symbolication (EI-27): `resolved` ones, and `unresolved` .js/.mjs/.cjs
@@ -55,10 +78,25 @@ export declare function inAppFrameResolution(frames: readonly StackFrame[] | und
 };
 /** Path-only form of a script URL — the key uploads are stored under. */
 export declare function scriptPath(filename: string): string | null;
+/**
+ * The path form of a server frame's file, comparable with stored upload
+ * paths: `file:///app/dist/index.mjs` → `/app/dist/index.mjs`,
+ * `C:\app\dist\index.js` → `/app/dist/index.js`, `index.js` (a Worker
+ * script) → `/index.js`. Null when it is not a path.
+ */
+export declare function serverScriptPath(filename: string): string | null;
 export interface SourceMapCacheOptions {
     /** 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;
+    /**
+     * Budget for the source contents of cached maps (RF-05; default:
+     * `maxBytes`). They are kept apart from the maps, one entry per source
+     * file and bounded the same way (least recently used first, a file over
+     * half the budget not kept), so a map caches exactly as it would without
+     * them.
+     */
+    maxContentBytes?: number;
     maxEntries?: number;
     /** How long a found map is reused (default 1 h). */
     hitTtlMs?: number;
@@ -70,22 +108,43 @@ export interface SourceMapCacheOptions {
 }
 /** 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`. */
+    /** Sources, names and ignore list. Its own `mappings` are left empty
+     * (positions go through `lookup`), and it holds no `sourcesContent`
+     * (see `contentOf`). */
     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. */
+    /** Estimated heap: decoded mappings (when decoded), strings and scopes;
+     * source contents are not part of it. */
     bytes: number;
     /** False when the map was too big to keep, so its mappings were not decoded. */
     cacheable: boolean;
+    /**
+     * The stored original source of `sources[index]` (in-app sources only),
+     * or null. For a cached map it is read from the cache's separate content
+     * store, so a content evicted there gives null (no context lines) until
+     * the map is parsed again.
+     */
+    contentOf(index: number): string | null;
+}
+/** A parsed map and its source contents, which are never part of the map's cache entry. */
+export interface ParsedSourceMap {
+    loaded: LoadedSourceMap;
+    /** `sourcesContent` as stored (aligned with `sources`), or null. */
+    contents: Array<string | null> | null;
 }
 export declare class SourceMapCache {
     private readonly entries;
     private readonly inFlight;
     private weight;
+    /** Source contents of cached maps, keyed by parse id and source index. */
+    private readonly contents;
+    private contentWeight;
+    /** Distinguishes every parse, so a re-parsed (maybe re-uploaded) map never reads an older parse's contents. */
+    private parses;
     private readonly maxBytes;
+    private readonly maxContentBytes;
     private readonly maxEntries;
     private readonly hitTtlMs;
     private readonly missTtlMs;
@@ -100,9 +159,14 @@ export declare class SourceMapCache {
     get size(): number;
     /** Estimated bytes of the cached maps (what `maxBytes` bounds). */
     get bytes(): number;
+    /** Estimated bytes of the cached source contents (what `maxContentBytes` bounds). */
+    get contentBytes(): number;
     /** The parsed map for `key` (null when none), fetching at most once at a time. */
     get(key: SourceMapKey, fetchMap: MapFetcher): Promise<LoadedSourceMap | null>;
     private load;
+    private contentOf;
+    private storeContent;
+    private removeContent;
     private store;
     private remove;
 }
@@ -113,7 +177,15 @@ export declare class SourceMapCache {
  * 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.
+ *
+ * `sourcesContent` (RF-05) is taken out before anything else: the TraceMap
+ * never holds it and `bytes` never counts it, so whether a map is decoded
+ * and cached is decided exactly as for a map uploaded without contents.
+ * They are returned beside the map; SourceMapCache keeps them in their own
+ * store.
  */
+export declare function parseSourceMapWithContents(json: string, maxDecodedBytes?: number): ParsedSourceMap;
+/** parseSourceMapWithContents, the map alone (its contents through `contentOf`). */
 export declare function parseSourceMap(json: string, maxDecodedBytes?: number): LoadedSourceMap;
 export declare class Symbolicator {
     private readonly fetchMap;