@autter/runtime-cli 1.0.0 → 1.2.0

package/dist/next.cjs

@@ -26,40 +26,11 @@ __export(next_exports, {
 });
 module.exports = __toCommonJS(next_exports);
 var import_node_module = require("module");
-var import_node_path3 = require("path");
-
-// src/inject.ts
-var import_promises2 = require("fs/promises");
+var import_node_path4 = require("path");
 
-// src/debug-id.ts
-var import_node_crypto = require("crypto");
-var DEBUG_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
-function normalizeDebugId(value) {
-  if (typeof value !== "string") return null;
-  const id = value.trim().toLowerCase();
-  return DEBUG_ID_RE.test(id) ? id : null;
-}
-function debugIdFor(bytes) {
-  const hash = (0, import_node_crypto.createHash)("sha256").update(bytes).digest();
-  hash[6] = hash[6] & 15 | 64;
-  hash[8] = hash[8] & 63 | 128;
-  const hex = hash.subarray(0, 16).toString("hex");
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
-}
-var DEBUG_ID_COMMENT_RE = /^\/\/# debugId=([0-9a-fA-F-]{36})[ \t]*\r?$/gm;
-function readDebugIdComment(code) {
-  let found = null;
-  for (const match of code.matchAll(DEBUG_ID_COMMENT_RE)) found = normalizeDebugId(match[1]) ?? found;
-  return found;
-}
-var DEBUG_ID_REGISTRY = "_autterDebugIds";
-function debugIdSnippet(id) {
-  return `;!function(){try{var g="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof window?window:"undefined"!=typeof self?self:{},s=(new g.Error).stack;s&&((g.${DEBUG_ID_REGISTRY}=g.${DEBUG_ID_REGISTRY}||{})[s]="${id}")}catch(e){}}();`;
-}
-var SNIPPET_RE = /\(g\._autterDebugIds=g\._autterDebugIds\|\|\{\}\)\[s\]="[0-9a-f]{8}-/;
-function hasDebugIdSnippet(code) {
-  return SNIPPET_RE.test(code);
-}
+// src/build.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
 
 // src/files.ts
 var import_node_fs = require("fs");
@@ -99,7 +70,7 @@ function mapPathFor(js, code) {
   const sibling = `${js}.map`;
   return (0, import_node_fs.existsSync)(sibling) ? sibling : null;
 }
-async function walk(dir, out) {
+async function walk(dir, out, pattern = BUNDLE_RE) {
   let entries;
   try {
     entries = await (0, import_promises.readdir)(dir, { withFileTypes: true });
@@ -109,9 +80,51 @@ async function walk(dir, out) {
   for (const entry of entries) {
     if (entry.name === "node_modules") continue;
     const full = (0, import_node_path.join)(dir, entry.name);
-    if (entry.isDirectory()) await walk(full, out);
-    else if (entry.isFile() && BUNDLE_RE.test(entry.name)) out.push(full);
+    if (entry.isDirectory()) await walk(full, out, pattern);
+    else if (entry.isFile() && pattern.test(entry.name)) out.push(full);
+  }
+}
+async function findMapFiles(dir) {
+  const out = [];
+  await walk((0, import_node_path.resolve)(dir), out, /\.map$/);
+  return out.sort();
+}
+var CSS_SOURCE_MAPPING_URL_RE = /\/\*[#@] sourceMappingURL=([^\s*]+)\s*\*\/\s*$/;
+function pointsAt(file, url, map) {
+  if (!url || /^[a-z][\w+.-]*:/i.test(url) || url.startsWith("/")) return false;
+  let path = url.split(/[?#]/)[0];
+  try {
+    path = decodeURIComponent(path);
+  } catch {
+  }
+  return (0, import_node_path.resolve)((0, import_node_path.dirname)(file), path) === map;
+}
+async function stripReference(file, map) {
+  let code;
+  try {
+    code = await (0, import_promises.readFile)(file, "utf8");
+  } catch {
+    return;
+  }
+  let stripped = code;
+  if (BUNDLE_RE.test(file)) {
+    if (pointsAt(file, readSourceMappingUrl(code), map)) stripped = stripSourceMappingUrl(code);
+  } else if (file.endsWith(".css")) {
+    const match = CSS_SOURCE_MAPPING_URL_RE.exec(code);
+    if (match && pointsAt(file, match[1], map)) stripped = code.slice(0, match.index).replace(/\n?$/, "\n");
   }
+  if (stripped !== code) await (0, import_promises.writeFile)(file, stripped);
+}
+async function removeSourceMaps(maps, owners = /* @__PURE__ */ new Map()) {
+  const removed = [];
+  for (const map of [...new Set(maps)].sort()) {
+    if (!(0, import_node_fs.existsSync)(map)) continue;
+    await (0, import_promises.rm)(map, { force: true });
+    removed.push(map);
+    const owner = owners.get(map) ?? map.replace(/\.map$/, "");
+    await stripReference(owner, map);
+  }
+  return removed;
 }
 async function findBundles(dir, files) {
   const root = (0, import_node_path.resolve)(dir);
@@ -135,6 +148,39 @@ async function findBundles(dir, files) {
   return bundles;
 }
 
+// src/inject.ts
+var import_promises2 = require("fs/promises");
+
+// src/debug-id.ts
+var import_node_crypto = require("crypto");
+var DEBUG_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+function normalizeDebugId(value) {
+  if (typeof value !== "string") return null;
+  const id = value.trim().toLowerCase();
+  return DEBUG_ID_RE.test(id) ? id : null;
+}
+function debugIdFor(bytes) {
+  const hash = (0, import_node_crypto.createHash)("sha256").update(bytes).digest();
+  hash[6] = hash[6] & 15 | 64;
+  hash[8] = hash[8] & 63 | 128;
+  const hex = hash.subarray(0, 16).toString("hex");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}
+var DEBUG_ID_COMMENT_RE = /^\/\/# debugId=([0-9a-fA-F-]{36})[ \t]*\r?$/gm;
+function readDebugIdComment(code) {
+  let found = null;
+  for (const match of code.matchAll(DEBUG_ID_COMMENT_RE)) found = normalizeDebugId(match[1]) ?? found;
+  return found;
+}
+var DEBUG_ID_REGISTRY = "_autterDebugIds";
+function debugIdSnippet(id) {
+  return `;!function(){try{var g="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof window?window:"undefined"!=typeof self?self:{},s=(new g.Error).stack;s&&((g.${DEBUG_ID_REGISTRY}=g.${DEBUG_ID_REGISTRY}||{})[s]="${id}")}catch(e){}}();`;
+}
+var SNIPPET_RE = /\(g\._autterDebugIds=g\._autterDebugIds\|\|\{\}\)\[s\]="[0-9a-f]{8}-/;
+function hasDebugIdSnippet(code) {
+  return SNIPPET_RE.test(code);
+}
+
 // src/inject.ts
 var SNIPPET_LINE_KEY = "x_autter_snippet_line";
 function snippetLine(code) {
@@ -237,6 +283,8 @@ async function injectDir(dir, options = {}) {
 // src/upload.ts
 var import_node_crypto2 = require("crypto");
 var import_promises3 = require("fs/promises");
+var import_node_util = require("util");
+var import_node_zlib = require("zlib");
 
 // src/release.ts
 var import_node_child_process = require("child_process");
@@ -282,9 +330,385 @@ function resolveRelease(explicit, env = process.env, cwd = process.cwd()) {
   );
 }
 
+// src/scopes.ts
+var import_acorn = require("acorn");
+var SCOPES_KEY = "x_autter_scopes";
+var SCOPES_VERSION = 1;
+var BASE_OPTIONS = {
+  ecmaVersion: "latest",
+  allowHashBang: true,
+  allowReturnOutsideFunction: true,
+  allowReserved: true
+};
+function parseBundle(code) {
+  try {
+    return (0, import_acorn.parse)(code, {
+      ...BASE_OPTIONS,
+      sourceType: "module",
+      allowAwaitOutsideFunction: true,
+      allowImportExportEverywhere: true
+    });
+  } catch (moduleError) {
+    try {
+      return (0, import_acorn.parse)(code, { ...BASE_OPTIONS, sourceType: "script" });
+    } catch (scriptError) {
+      const pos = (err) => typeof err.pos === "number" ? err.pos : -1;
+      throw pos(scriptError) > pos(moduleError) ? scriptError : moduleError;
+    }
+  }
+}
+function isNode(value) {
+  return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+var IDENTIFIER_NAME_RE = /^[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*$/u;
+function identifierToken(node) {
+  if (!isNode(node)) return null;
+  if (node.type === "Identifier") return { offset: node.start, name: node.name, literal: false };
+  if (node.type === "PrivateIdentifier") return { offset: node.start, name: `#${node.name}`, literal: false };
+  return null;
+}
+function literalToken(node) {
+  if (!isNode(node) || node.type !== "Literal" || typeof node.value !== "string") return null;
+  return IDENTIFIER_NAME_RE.test(node.value) ? { offset: node.start, name: node.value, literal: true } : null;
+}
+function keyToken(property) {
+  if (!property.computed) {
+    const id = identifierToken(property.key);
+    if (id) return id;
+  }
+  return literalToken(property.key);
+}
+function bindingToken(target) {
+  if (!isNode(target)) return null;
+  if (target.type === "Identifier") return identifierToken(target);
+  if (target.type === "MemberExpression") {
+    return target.computed ? literalToken(target.property) : identifierToken(target.property);
+  }
+  return null;
+}
+function contextTokens(node, parent) {
+  let token = null;
+  switch (parent?.type) {
+    case "VariableDeclarator":
+      if (parent.init === node) token = bindingToken(parent.id);
+      break;
+    case "AssignmentExpression":
+    case "AssignmentPattern":
+      if (parent.right === node) token = bindingToken(parent.left);
+      break;
+    case "Property":
+    case "PropertyDefinition":
+    case "MethodDefinition":
+      if (parent.value === node) token = keyToken(parent);
+      break;
+  }
+  return token ? [token] : [];
+}
+function classTokens(path) {
+  if (!path || path.node.type !== "ClassDeclaration" && path.node.type !== "ClassExpression") return [];
+  const own = identifierToken(path.node.id);
+  return [...own ? [own] : [], ...contextTokens(path.node, path.parent?.node)];
+}
+function describe(path) {
+  const fn = path.node;
+  const parent = path.parent?.node;
+  const own = identifierToken(fn.id);
+  const isMethod = parent?.type === "MethodDefinition" || parent?.type === "Property" && parent.value === fn && (parent.method === true || parent.kind !== "init");
+  let context;
+  if (parent?.type === "MethodDefinition" && parent.kind === "constructor") {
+    context = classTokens(path.parent?.parent?.parent ?? null);
+  } else {
+    context = contextTokens(fn, parent);
+  }
+  return {
+    start: fn.start,
+    end: fn.end,
+    own,
+    recoverAt: !own && fn.type !== "ArrowFunctionExpression" && !isMethod ? fn.start : null,
+    context
+  };
+}
+var FUNCTION_TYPES = /* @__PURE__ */ new Set(["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"]);
+function classInitializer(path) {
+  const node = path.node;
+  let range = null;
+  if (node.type === "StaticBlock") range = node;
+  else if (node.type === "PropertyDefinition" && isNode(node.value) && !FUNCTION_TYPES.has(node.value.type)) range = node.value;
+  if (!range) return null;
+  return { start: range.start, end: range.end, own: null, recoverAt: null, context: classTokens(path.parent?.parent ?? null) };
+}
+function collectFunctions(program) {
+  const found = [];
+  const stack = [{ node: program, parent: null }];
+  for (let path = stack.pop(); path; path = stack.pop()) {
+    const node = path.node;
+    if (FUNCTION_TYPES.has(node.type)) found.push(describe(path));
+    else {
+      const initializer = classInitializer(path);
+      if (initializer) found.push(initializer);
+    }
+    for (const key in node) {
+      const value = node[key];
+      if (Array.isArray(value)) {
+        for (let i = value.length - 1; i >= 0; i--) if (isNode(value[i])) stack.push({ node: value[i], parent: path });
+      } else if (isNode(value)) {
+        stack.push({ node: value, parent: path });
+      }
+    }
+  }
+  return found;
+}
+function lineStarts(code) {
+  const starts = [0];
+  for (let i = 0; i < code.length; i++) {
+    const c = code.charCodeAt(i);
+    if (c === 10 || c === 8232 || c === 8233) starts.push(i + 1);
+    else if (c === 13) {
+      if (code.charCodeAt(i + 1) === 10) i++;
+      starts.push(i + 1);
+    }
+  }
+  return starts;
+}
+function positionOf(starts, offset) {
+  let lo = 0;
+  let hi = starts.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (starts[mid] <= offset) lo = mid;
+    else hi = mid - 1;
+  }
+  return [lo, offset - starts[lo]];
+}
+var BASE64 = new Int8Array(128).fill(-1);
+for (const [i, ch] of [..."ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"].entries()) BASE64[ch.charCodeAt(0)] = i;
+function findSegments(mappings, wanted) {
+  let line = 0;
+  let column = 0;
+  let source = 0;
+  let originalLine = 0;
+  let originalColumn = 0;
+  let name = 0;
+  let want = wanted.get(0);
+  const fields = [0, 0, 0, 0, 0];
+  let i = 0;
+  while (i < mappings.length) {
+    const ch = mappings.charCodeAt(i);
+    if (ch === 59) {
+      line++;
+      column = 0;
+      want = wanted.get(line);
+      i++;
+      continue;
+    }
+    if (ch === 44) {
+      i++;
+      continue;
+    }
+    let count = 0;
+    while (i < mappings.length) {
+      const next = mappings.charCodeAt(i);
+      if (next === 44 || next === 59) break;
+      let value = 0;
+      let shift = 0;
+      let digit;
+      do {
+        const code = mappings.charCodeAt(i++);
+        digit = code < 128 ? BASE64[code] : -1;
+        if (digit < 0 || shift > 30) throw new Error("invalid mappings");
+        value |= (digit & 31) << shift;
+        shift += 5;
+      } while (digit & 32);
+      const decoded = value & 1 ? -(value >>> 1) : value >>> 1;
+      if (count < 5) fields[count] = decoded;
+      count++;
+    }
+    column += fields[0];
+    if (count >= 4) {
+      source += fields[1];
+      originalLine += fields[2];
+      originalColumn += fields[3];
+    }
+    if (count >= 5) name += fields[4];
+    if (want && want.get(column) === null) {
+      want.set(column, {
+        source: count >= 4 ? source : -1,
+        line: originalLine,
+        column: originalColumn,
+        name: count >= 5 ? name : -1
+      });
+    }
+  }
+}
+function looksMangled(name) {
+  return name.replace(/^#/, "").length <= 2;
+}
+var IDENTIFIER_AT_RE = /[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*/uy;
+var OWN_NAME_AT_RE = /(?:async\s+)?function\b\s*\*?\s*([$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*)/uy;
+var NOT_A_NAME = new Set(
+  "abstract async await break case catch class const continue debugger declare default delete do else enum export extends false finally for function get if implements import in instanceof interface let new null of override package private protected public readonly return set static super switch this throw true try typeof var void while with yield".split(" ")
+);
+var NameResolver = class {
+  constructor(map, segmentAt) {
+    this.segmentAt = segmentAt;
+    this.names = Array.isArray(map.names) ? map.names : [];
+    this.sourcesContent = Array.isArray(map.sourcesContent) ? map.sourcesContent : [];
+  }
+  segmentAt;
+  names;
+  sourcesContent;
+  sourceLines = /* @__PURE__ */ new Map();
+  originalLine(segment) {
+    if (segment.source < 0) return null;
+    let lines = this.sourceLines.get(segment.source);
+    if (lines === void 0) {
+      const content = this.sourcesContent[segment.source];
+      lines = typeof content === "string" ? content.split(/\r\n|[\n\r\u2028\u2029]/) : null;
+      this.sourceLines.set(segment.source, lines);
+    }
+    return lines?.[segment.line] ?? null;
+  }
+  /** The original identifier at a segment's source position. */
+  identifierAt(segment, re, group = 0) {
+    const text = this.originalLine(segment);
+    if (text === null) return null;
+    re.lastIndex = segment.column;
+    const found = re.exec(text)?.[group];
+    return found && !NOT_A_NAME.has(found) ? found : null;
+  }
+  /** Original name of a token: the map's `names` at its exact position;
+   * else the generated name when it isn't mangled; else the identifier
+   * at the mapped position in `sourcesContent`. Null when unknown. */
+  resolve(token) {
+    if (token.literal) return token.name;
+    const segment = this.segmentAt(token.offset);
+    if (segment && segment.name >= 0) {
+      const name = this.names[segment.name];
+      if (typeof name === "string" && name) return name;
+    }
+    if (!looksMangled(token.name)) return token.name;
+    return segment ? this.identifierAt(segment, IDENTIFIER_AT_RE) : null;
+  }
+  /** The name a minifier removed from `function name() {}`, read from the
+   * original source at the function's mapped start. */
+  recover(offset) {
+    const segment = this.segmentAt(offset);
+    return segment ? this.identifierAt(segment, OWN_NAME_AT_RE, 1) : null;
+  }
+};
+var BASE64_DIGITS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function vlq(value) {
+  let rest = value < 0 ? -value << 1 | 1 : value << 1;
+  let out = "";
+  do {
+    let digit = rest & 31;
+    rest >>>= 5;
+    if (rest > 0) digit |= 32;
+    out += BASE64_DIGITS[digit];
+  } while (rest > 0);
+  return out;
+}
+function encodeScopes(entries) {
+  const parts = [];
+  let line = 0;
+  let previousStart = 0;
+  let previousName = 0;
+  let firstOnLine = true;
+  for (const [startLine, startColumn, endLine, endColumn, nameIndex] of entries) {
+    if (startLine > line) {
+      parts.push(";".repeat(startLine - line));
+      line = startLine;
+      previousStart = 0;
+      firstOnLine = true;
+    }
+    if (!firstOnLine) parts.push(",");
+    firstOnLine = false;
+    let segment = vlq(startColumn - previousStart) + vlq(endLine - startLine) + vlq(endLine === startLine ? endColumn - startColumn : endColumn);
+    previousStart = startColumn;
+    if (nameIndex >= 0) {
+      segment += vlq(nameIndex - previousName);
+      previousName = nameIndex;
+    }
+    parts.push(segment);
+  }
+  return parts.join("");
+}
+function computeScopes(code, map) {
+  try {
+    return scopesOf(code, map);
+  } catch (err) {
+    return { error: err instanceof Error ? err.message : String(err) };
+  }
+}
+function scopesOf(code, map) {
+  if (typeof map.mappings !== "string") return { error: "the map has no mappings string" };
+  let functions;
+  try {
+    functions = collectFunctions(parseBundle(code));
+  } catch (err) {
+    return { error: `could not parse the bundle: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  const starts = lineStarts(code);
+  const wanted = /* @__PURE__ */ new Map();
+  const want = (offset) => {
+    const [line, column] = positionOf(starts, offset);
+    let columns = wanted.get(line);
+    if (!columns) wanted.set(line, columns = /* @__PURE__ */ new Map());
+    columns.set(column, null);
+  };
+  for (const fn of functions) {
+    if (fn.own && !fn.own.literal) want(fn.own.offset);
+    if (fn.recoverAt !== null) want(fn.recoverAt);
+    for (const token of fn.context) if (!token.literal) want(token.offset);
+  }
+  try {
+    findSegments(map.mappings, wanted);
+  } catch (err) {
+    return { error: `could not read the map: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  const resolver = new NameResolver(map, (offset) => {
+    const [line, column] = positionOf(starts, offset);
+    return wanted.get(line)?.get(column) ?? null;
+  });
+  functions.sort((a, b) => a.start - b.start || b.end - a.end);
+  const mapNames = Array.isArray(map.names) ? map.names : [];
+  const nameIndex = /* @__PURE__ */ new Map();
+  mapNames.forEach((name, index) => {
+    if (typeof name === "string" && !nameIndex.has(name)) nameIndex.set(name, index);
+  });
+  const extraNames = [];
+  const indexOf = (name) => {
+    let index = nameIndex.get(name);
+    if (index === void 0) {
+      index = mapNames.length + extraNames.push(name) - 1;
+      nameIndex.set(name, index);
+    }
+    return index;
+  };
+  const entries = functions.map((fn) => {
+    let name = fn.own ? resolver.resolve(fn.own) : null;
+    if (name === null && fn.recoverAt !== null) name = resolver.recover(fn.recoverAt);
+    for (const token of fn.context) {
+      if (name !== null) break;
+      name = resolver.resolve(token);
+    }
+    const index = name !== null ? indexOf(name) : fn.own || fn.context.length > 0 ? indexOf(null) : -1;
+    const [startLine, startColumn] = positionOf(starts, fn.start);
+    const [endLine, endColumn] = positionOf(starts, fn.end);
+    return [startLine, startColumn, endLine, endColumn, index];
+  });
+  return { scopes: { version: SCOPES_VERSION, names: extraNames, scopes: encodeScopes(entries) } };
+}
+
 // src/upload.ts
 var DEFAULT_ENDPOINT = "https://otlp.autter.dev";
-var MAX_UPLOAD_BYTES = 5 * 1024 * 1024;
+var MAX_MAP_CHARS = 32 * 1024 * 1024;
+var MAX_UPLOAD_BYTES = MAX_MAP_CHARS + 1024 * 1024;
+var LEGACY_MAX_BYTES = 5 * 1024 * 1024;
+var UPLOAD_KEY_PREFIX = "autter_rtu_";
+var CLIENT_KEY_PREFIX = "autter_rtc_";
+var KEY_ADVICE = "set AUTTER_RUNTIME_KEY to an upload-only key (autter_rtu_\u2026, recommended for CI: it can only upload source maps) or the full server key (autter_rt_\u2026, also works)";
+var gzip = (0, import_node_util.promisify)(import_node_zlib.gzip);
 var CHECK_BATCH = 500;
 var MAX_ATTEMPTS = 3;
 function resolveEndpoint(flag, env = process.env) {
@@ -301,7 +725,16 @@ function storedMapJson(map) {
   const { sourcesContent: _omitted, ...safe } = map;
   return JSON.stringify(safe);
 }
-async function prepare(bundle, urlPrefix, release) {
+function bytesOf(buffer) {
+  return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+}
+function fits(json, body) {
+  return json.length <= MAX_MAP_CHARS && Buffer.byteLength(body) <= MAX_UPLOAD_BYTES;
+}
+function uploadBody(release, filename, debugId, json) {
+  return `{"release":${JSON.stringify(release)},"filename":${JSON.stringify(filename)},${debugId ? `"debugId":${JSON.stringify(debugId)},` : ""}"map":${json}}`;
+}
+async function prepare(bundle, urlPrefix, release, log, compress) {
   let map;
   try {
     map = JSON.parse(await (0, import_promises3.readFile)(bundle.map, "utf8"));
@@ -313,17 +746,31 @@ async function prepare(bundle, urlPrefix, release) {
   }
   const code = await (0, import_promises3.readFile)(bundle.js, "utf8");
   const debugId = readDebugIdComment(code) ?? normalizeDebugId(map.debugId);
-  const json = storedMapJson(map);
   const filename = servedFilename(urlPrefix, bundle.path);
-  const body = `{"release":${JSON.stringify(release)},"filename":${JSON.stringify(filename)},${debugId ? `"debugId":${JSON.stringify(debugId)},` : ""}"map":${json}}`;
+  const { [SCOPES_KEY]: _stale, ...plain } = map;
+  const scopes = computeScopes(code, map);
+  let json = storedMapJson(plain);
+  if ("scopes" in scopes) {
+    const scoped = storedMapJson({ ...plain, [SCOPES_KEY]: scopes.scopes });
+    if (fits(scoped, uploadBody(release, filename, debugId, scoped))) json = scoped;
+    else if (fits(json, uploadBody(release, filename, debugId, json))) {
+      log(`warning: ${bundle.path}: its map is over 32 MB with function scopes, so it is uploaded without them (frames keep call-site names)`);
+    }
+  } else {
+    log(`warning: ${bundle.path}: no function scopes (${scopes.error}); its map is uploaded without them (frames keep call-site names)`);
+  }
+  const body = uploadBody(release, filename, debugId, json);
   return {
     bundle,
-    body,
+    // Maps are text that compresses several times over; the ingester
+    // inflates the body (Content-Encoding: gzip).
+    body: compress && fits(json, body) ? bytesOf(await gzip(body)) : new Uint8Array(0),
     path: bundle.path,
     filename,
     debugId,
     hash: (0, import_node_crypto2.createHash)("sha256").update(json).digest("hex"),
-    bytes: Buffer.byteLength(body)
+    bytes: Buffer.byteLength(body),
+    mapChars: json.length
   };
 }
 var FatalUploadError = class extends Error {
@@ -351,14 +798,14 @@ async function uploadDir(dir, options = {}) {
   };
   const items = [];
   for (const bundle of await findBundles(dir, options.files)) {
-    const prepared = await prepare(bundle, options.urlPrefix, release);
+    const prepared = await prepare(bundle, options.urlPrefix, release, log, !options.dryRun);
     if ("error" in prepared) {
       summary.failed.push({ path: bundle.path, filename: servedFilename(options.urlPrefix, bundle.path), error: prepared.error });
-    } else if (prepared.bytes > MAX_UPLOAD_BYTES) {
+    } else if (prepared.mapChars > MAX_MAP_CHARS || prepared.bytes > MAX_UPLOAD_BYTES) {
       summary.failed.push({
         path: prepared.path,
         filename: prepared.filename,
-        error: `map is ${(prepared.bytes / 1048576).toFixed(1)} MB without sourcesContent; the ingester accepts up to 5 MB`
+        error: `map is ${(prepared.mapChars / 1048576).toFixed(1)} MB without sourcesContent; the ingester accepts up to 32 MB`
       });
     } else {
       items.push(prepared);
@@ -369,11 +816,15 @@ async function uploadDir(dir, options = {}) {
     return summary;
   }
   const key = (options.key ?? env.AUTTER_RUNTIME_KEY ?? "").trim();
-  if (!key) throw new FatalUploadError("no ingest key: set AUTTER_RUNTIME_KEY to a server key (autter_rt_\u2026)");
-  if (key.startsWith("autter_rtc_")) {
-    throw new FatalUploadError("AUTTER_RUNTIME_KEY is a publishable client key (autter_rtc_\u2026); uploads need a server key (autter_rt_\u2026)");
+  if (!key) throw new FatalUploadError(`no ingest key: ${KEY_ADVICE}`);
+  if (key.startsWith(CLIENT_KEY_PREFIX)) {
+    throw new FatalUploadError(`AUTTER_RUNTIME_KEY is a publishable client key (autter_rtc_\u2026), which cannot upload source maps: ${KEY_ADVICE}`);
   }
+  const rejected = (status, detail) => new FatalUploadError(
+    `the ingester rejected the key (${status}): ${detail}` + (key.startsWith(UPLOAD_KEY_PREFIX) ? " (upload keys, autter_rtu_\u2026, need ingester 1.7.0 or later; the server key works with any)" : "")
+  );
   const headers = { "content-type": "application/json", authorization: `Bearer ${key}` };
+  const uploadHeaders = { ...headers, "content-encoding": "gzip" };
   const skipped = /* @__PURE__ */ new Set();
   for (let start = 0; start < items.length && !summary.legacyIngester; start += CHECK_BATCH) {
     const batch = items.slice(start, start + CHECK_BATCH);
@@ -393,9 +844,7 @@ async function uploadDir(dir, options = {}) {
         );
         break;
       }
-      if (res.status === 401 || res.status === 403) {
-        throw new FatalUploadError(`the ingester rejected the key (${res.status}): ${(await res.text()).slice(0, 300)}`);
-      }
+      if (res.status === 401 || res.status === 403) throw rejected(res.status, (await res.text()).slice(0, 300));
       if (!res.ok) throw new Error(`HTTP ${res.status}`);
       const body = await res.json();
       const present = new Set(Array.isArray(body.present) ? body.present : []);
@@ -415,7 +864,7 @@ async function uploadDir(dir, options = {}) {
       let status = 0;
       let detail = "";
       try {
-        const res = await doFetch(`${endpoint}/v1/sourcemaps`, { method: "POST", headers, body: item.body });
+        const res = await doFetch(`${endpoint}/v1/sourcemaps`, { method: "POST", headers: uploadHeaders, body: item.body });
         status = res.status;
         if (res.ok) {
           uploaded.push(item);
@@ -426,12 +875,16 @@ async function uploadDir(dir, options = {}) {
         detail = err.message;
       }
       if (status === 401 || status === 403) {
-        fatal = new FatalUploadError(`the ingester rejected the key (${status}): ${detail}`);
+        fatal = rejected(status, detail);
         return;
       }
       const retryable = status === 0 || status === 429 || status >= 500;
       if (!retryable || attempt >= MAX_ATTEMPTS) {
-        summary.failed.push({ path: item.path, filename: item.filename, error: status ? `HTTP ${status}: ${detail}` : detail });
+        let error = status ? `HTTP ${status}: ${detail}` : detail;
+        if (status === 413 && item.bytes > LEGACY_MAX_BYTES) {
+          error += ` (this map is ${(item.bytes / 1048576).toFixed(1)} MB; ingester 1.6.0 and older accept up to 5 MB, newer ones 32 MB)`;
+        }
+        summary.failed.push({ path: item.path, filename: item.filename, error });
         return;
       }
       await sleep(500 * 2 ** (attempt - 1));
@@ -464,6 +917,18 @@ function strip(item) {
 }
 
 // src/build.ts
+function buildKey(options) {
+  const key = (options.key ?? process.env.AUTTER_RUNTIME_KEY ?? "").trim();
+  return key || null;
+}
+function shouldGenerateMaps(options) {
+  return options.upload === false || Boolean(options.dryRun) || buildKey(options) !== null;
+}
+function logMapsNotGenerated(options) {
+  if (!options.silent) {
+    console.log("[autter-runtime] AUTTER_RUNTIME_KEY is not set: no source maps generated, nothing uploaded");
+  }
+}
 function formatUploadSummary(summary) {
   const lines = [];
   const verb = summary.dryRun ? "would upload" : "uploaded";
@@ -482,71 +947,131 @@ async function processBuildOutput(input) {
   const log = (line) => {
     if (!options.silent) console.log(`[autter-runtime] ${line}`);
   };
-  const result = { injected: [], upload: null };
+  const result = { injected: [], upload: null, removedMaps: [] };
+  let outcome = "they were uploaded";
+  const owners = /* @__PURE__ */ new Map();
+  if (input.ownMaps) {
+    for (const bundle of await findBundles(input.dir, input.files)) owners.set(bundle.map, bundle.js);
+  }
   try {
-    result.injected = await injectDir(input.dir, {
-      files: input.files,
-      dryRun: options.dryRun,
-      stripSourceMappingUrl: input.stripSourceMappingUrl
-    });
-    const changed = result.injected.filter((r) => r.status === "injected").length;
-    if (result.injected.length) {
-      log(`debug ids: ${changed} bundle(s) injected, ${result.injected.length - changed} already had one`);
-    }
-    for (const bad of result.injected.filter((r) => r.status === "invalid-map")) log(`skipped ${bad.path}: its map is not valid JSON`);
-    if (options.upload === false) return result;
-    const key = options.key ?? process.env.AUTTER_RUNTIME_KEY;
-    if (!key && !options.dryRun) {
-      if (result.injected.length) log("AUTTER_RUNTIME_KEY is not set: source maps were not uploaded");
-      return result;
-    }
-    if (!result.injected.some((r) => r.status !== "invalid-map")) return result;
-    result.upload = await uploadDir(input.dir, {
-      files: input.files,
-      release: options.release,
-      urlPrefix: options.urlPrefix ?? input.urlPrefix,
-      endpoint: options.endpoint,
-      key,
-      dryRun: options.dryRun,
-      concurrency: options.concurrency,
-      deleteAfterUpload: options.deleteAfterUpload ?? input.deleteAfterUpload,
-      log
-    });
-    for (const line of formatUploadSummary(result.upload)) log(line);
-    if (result.upload.failed.length && options.failOnError) {
-      throw new Error(`${result.upload.failed.length} source map upload(s) failed`);
+    try {
+      result.injected = await injectDir(input.dir, {
+        files: input.files,
+        dryRun: options.dryRun,
+        stripSourceMappingUrl: input.stripSourceMappingUrl
+      });
+      const changed = result.injected.filter((r) => r.status === "injected").length;
+      if (result.injected.length) {
+        log(`debug ids: ${changed} bundle(s) injected, ${result.injected.length - changed} already had one`);
+      }
+      for (const bad of result.injected.filter((r) => r.status === "invalid-map")) log(`skipped ${bad.path}: its map is not valid JSON`);
+      if (options.upload === false) return result;
+      const key = buildKey(options);
+      if (!key && !options.dryRun) {
+        outcome = "AUTTER_RUNTIME_KEY is not set";
+        if (result.injected.length && !input.ownMaps) log("AUTTER_RUNTIME_KEY is not set: source maps were not uploaded");
+        return result;
+      }
+      if (!result.injected.some((r) => r.status !== "invalid-map")) {
+        outcome = "no bundle had a usable map to upload";
+        return result;
+      }
+      result.upload = await uploadDir(input.dir, {
+        files: input.files,
+        release: options.release,
+        urlPrefix: options.urlPrefix ?? input.urlPrefix,
+        endpoint: options.endpoint,
+        key: key ?? void 0,
+        dryRun: options.dryRun,
+        concurrency: options.concurrency,
+        deleteAfterUpload: options.deleteAfterUpload ?? input.deleteAfterUpload,
+        log
+      });
+      for (const line of formatUploadSummary(result.upload)) log(line);
+      const { failed, uploaded, skipped, dryRun } = result.upload;
+      if (dryRun) outcome = "dry run, nothing was uploaded";
+      else if (failed.length) {
+        outcome = `${failed.length} of ${failed.length + uploaded.length + skipped.length} could not be uploaded (${failed[0].error})`;
+      }
+      if (failed.length && options.failOnError) {
+        throw new Error(`${failed.length} source map upload(s) failed`);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (outcome === "they were uploaded") outcome = `the upload failed (${message})`;
+      if (options.failOnError) throw new Error(`[autter-runtime] source maps: ${message}`);
+      if (!options.silent) console.warn(`[autter-runtime] source maps: ${message}`);
     }
-  } catch (err) {
-    const message = `source maps: ${err instanceof Error ? err.message : String(err)}`;
-    if (options.failOnError) throw new Error(`[autter-runtime] ${message}`);
-    if (!options.silent) console.warn(`[autter-runtime] ${message}`);
+  } finally {
+    await cleanUp();
   }
   return result;
+  async function cleanUp() {
+    if (!input.ownMaps) return;
+    const maps = /* @__PURE__ */ new Set([...input.maps ?? [], ...owners.keys()]);
+    const rel = (path) => (0, import_node_path2.relative)(input.dir, path).split(import_node_path2.sep).join("/");
+    if (options.upload === false || options.deleteAfterUpload === false) {
+      const kept = [...maps].filter((map) => (0, import_node_fs2.existsSync)(map));
+      if (kept.length) {
+        log(
+          `kept ${kept.length} source map(s) this plugin generated (${options.upload === false ? "upload: false" : "deleteAfterUpload: false"}): they expose your source, so upload them with \`autter-runtime sourcemaps upload --delete-after-upload\` or keep them out of the deploy`
+        );
+      }
+      return;
+    }
+    try {
+      await removeSourceMaps(maps, owners);
+    } catch (err) {
+      const message = `could not delete the source maps this plugin generated (${err instanceof Error ? err.message : String(err)}): keep them out of the deploy`;
+      if (options.failOnError) throw new Error(`[autter-runtime] ${message}`);
+      if (!options.silent) console.warn(`[autter-runtime] ${message}`);
+    }
+    result.removedMaps = [...maps].filter((map) => !(0, import_node_fs2.existsSync)(map)).map(rel).sort();
+    if (result.removedMaps.length) {
+      log(`removed ${result.removedMaps.length} source map(s) this plugin generated, so they are not deployed: ${outcome}`);
+    }
+  }
 }
 
 // src/webpack.ts
-var import_node_path2 = require("path");
+var import_node_path3 = require("path");
 var PLUGIN_NAME = "AutterSourceMapsWebpackPlugin";
 var AutterSourceMapsWebpackPlugin = class {
-  constructor(options = {}) {
+  constructor(options = {}, internal = {}) {
     this.options = options;
+    this.internal = internal;
   }
   options;
+  internal;
   apply(compiler) {
     const mode = compiler.options.mode ?? (process.env.NODE_ENV === "development" ? "development" : void 0);
     if (mode === "development") return;
-    let enabledMaps = false;
+    let enabledMaps = this.internal.ownMaps ?? false;
     if (!compiler.options.devtool) {
-      compiler.options.devtool = "hidden-source-map";
-      enabledMaps = true;
+      if (shouldGenerateMaps(this.options)) {
+        compiler.options.devtool = "hidden-source-map";
+        enabledMaps = true;
+      } else {
+        logMapsNotGenerated(this.options);
+      }
     }
     compiler.hooks.afterEmit.tapPromise(PLUGIN_NAME, async (compilation) => {
       const dir = compilation.outputOptions.path ?? compiler.outputPath;
       if (!dir) return;
       const publicPath = compilation.outputOptions.publicPath;
       const urlPrefix = typeof publicPath === "string" && publicPath !== "auto" && publicPath !== "" ? publicPath : "/";
-      const files = compilation.getAssets().map((asset) => asset.name).filter((name) => BUNDLE_RE.test(name)).map((name) => (0, import_node_path2.resolve)(dir, name));
-      await processBuildOutput({ dir, files, urlPrefix, options: this.options, deleteAfterUpload: enabledMaps });
+      const assets = compilation.getAssets().map((asset) => asset.name);
+      const files = assets.filter((name) => BUNDLE_RE.test(name)).map((name) => (0, import_node_path3.resolve)(dir, name));
+      const maps = assets.filter((name) => name.endsWith(".map")).map((name) => (0, import_node_path3.resolve)(dir, name));
+      await processBuildOutput({
+        dir,
+        files,
+        maps,
+        urlPrefix,
+        options: this.options,
+        deleteAfterUpload: enabledMaps,
+        ownMaps: enabledMaps
+      });
     });
   }
 };
@@ -555,7 +1080,7 @@ var AutterSourceMapsWebpackPlugin = class {
 var AFTER_COMPILE_HOOK_SINCE = [15, 4, 1];
 function installedNextVersion(cwd = process.cwd()) {
   try {
-    const version = (0, import_node_module.createRequire)((0, import_node_path3.join)(cwd, "package.json"))("next/package.json").version;
+    const version = (0, import_node_module.createRequire)((0, import_node_path4.join)(cwd, "package.json"))("next/package.json").version;
     return typeof version === "string" ? version : null;
   } catch {
     return null;
@@ -572,7 +1097,15 @@ function hasAfterCompileHook(version) {
 }
 function wrapConfig(config, options) {
   const publicMaps = config.productionBrowserSourceMaps === true;
+  const ownMaps = !publicMaps && shouldGenerateMaps(options);
   const deleteAfterUpload = options.deleteAfterUpload ?? !publicMaps;
+  let notified = false;
+  const notifyNoMaps = () => {
+    if (!publicMaps && !ownMaps && !notified) {
+      notified = true;
+      logMapsNotGenerated(options);
+    }
+  };
   const base = String(config.assetPrefix || config.basePath || "").replace(/\/+$/, "");
   const nextPrefix = `${base}/_next/`;
   const useHook = hasAfterCompileHook(installedNextVersion());
@@ -582,11 +1115,14 @@ function wrapConfig(config, options) {
     webpack(webpackConfig, context) {
       const result = typeof userWebpack === "function" ? userWebpack(webpackConfig, context) : webpackConfig;
       if (!context.isServer && !context.dev) {
-        if (!publicMaps) result.devtool = "hidden-source-map";
+        if (ownMaps) result.devtool = "hidden-source-map";
         if (!useHook) {
           result.plugins = [
             ...result.plugins ?? [],
-            new AutterSourceMapsWebpackPlugin({ ...options, urlPrefix: options.urlPrefix ?? nextPrefix, deleteAfterUpload })
+            new AutterSourceMapsWebpackPlugin(
+              { ...options, urlPrefix: options.urlPrefix ?? nextPrefix, deleteAfterUpload },
+              { ownMaps }
+            )
           ];
         }
       }
@@ -594,19 +1130,24 @@ function wrapConfig(config, options) {
     }
   };
   if (useHook) {
-    wrapped.productionBrowserSourceMaps = true;
+    if (ownMaps) wrapped.productionBrowserSourceMaps = true;
     const userHook = config.compiler?.runAfterProductionCompile;
     wrapped.compiler = {
       ...config.compiler,
       async runAfterProductionCompile(ctx = {}) {
         if (typeof userHook === "function") await userHook(ctx);
-        const distDir = ctx.distDir ?? (0, import_node_path3.resolve)(ctx.projectDir ?? process.cwd(), String(config.distDir ?? ".next"));
+        const distDir = ctx.distDir ?? (0, import_node_path4.resolve)(ctx.projectDir ?? process.cwd(), String(config.distDir ?? ".next"));
+        const staticDir = (0, import_node_path4.join)(distDir, "static");
+        notifyNoMaps();
         await processBuildOutput({
-          dir: (0, import_node_path3.join)(distDir, "static"),
+          dir: staticDir,
           urlPrefix: options.urlPrefix ?? `${nextPrefix}static/`,
           options: { ...options, deleteAfterUpload },
           deleteAfterUpload,
-          stripSourceMappingUrl: !publicMaps
+          stripSourceMappingUrl: !publicMaps,
+          ownMaps,
+          // Every client map (JS and CSS): .next/static is deployed as is.
+          maps: ownMaps ? await findMapFiles(staticDir) : void 0
         });
       }
     };