@autter/runtime-cli 1.0.0 → 1.1.0

package/dist/index.cjs

@@ -25,10 +25,14 @@ __export(src_exports, {
   DEBUG_ID_REGISTRY: () => DEBUG_ID_REGISTRY,
   DEFAULT_ENDPOINT: () => DEFAULT_ENDPOINT,
   FatalUploadError: () => FatalUploadError,
+  MAX_MAP_CHARS: () => MAX_MAP_CHARS,
   MAX_UPLOAD_BYTES: () => MAX_UPLOAD_BYTES,
   RELEASE_ENV_VARS: () => RELEASE_ENV_VARS,
   RELEASE_RE: () => RELEASE_RE,
+  SCOPES_KEY: () => SCOPES_KEY,
+  SCOPES_VERSION: () => SCOPES_VERSION,
   SNIPPET_LINE_KEY: () => SNIPPET_LINE_KEY,
+  computeScopes: () => computeScopes,
   debugIdFor: () => debugIdFor,
   debugIdSnippet: () => debugIdSnippet,
   findBundles: () => findBundles,
@@ -121,7 +125,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 });
@@ -131,10 +135,47 @@ 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);
   }
 }
+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);
   const candidates = [];
@@ -260,6 +301,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");
@@ -305,9 +348,382 @@ 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 gzip = (0, import_node_util.promisify)(import_node_zlib.gzip);
 var CHECK_BATCH = 500;
 var MAX_ATTEMPTS = 3;
 function resolveEndpoint(flag, env = process.env) {
@@ -324,7 +740,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"));
@@ -336,17 +761,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 {
@@ -374,14 +813,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);
@@ -397,6 +836,7 @@ async function uploadDir(dir, options = {}) {
     throw new FatalUploadError("AUTTER_RUNTIME_KEY is a publishable client key (autter_rtc_\u2026); uploads need a server key (autter_rt_\u2026)");
   }
   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);
@@ -438,7 +878,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);
@@ -454,7 +894,11 @@ async function uploadDir(dir, options = {}) {
       }
       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));
@@ -487,6 +931,12 @@ function strip(item) {
 }
 
 // src/build.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+function buildKey(options) {
+  const key = (options.key ?? process.env.AUTTER_RUNTIME_KEY ?? "").trim();
+  return key || null;
+}
 function formatUploadSummary(summary) {
   const lines = [];
   const verb = summary.dryRun ? "would upload" : "uploaded";
@@ -505,46 +955,90 @@ 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`);
+    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}`);
     }
-    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;
+  } 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;
     }
-    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 {
+      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}`);
     }
-  } 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}`);
   }
-  return result;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -553,10 +1047,14 @@ async function processBuildOutput(input) {
   DEBUG_ID_REGISTRY,
   DEFAULT_ENDPOINT,
   FatalUploadError,
+  MAX_MAP_CHARS,
   MAX_UPLOAD_BYTES,
   RELEASE_ENV_VARS,
   RELEASE_RE,
+  SCOPES_KEY,
+  SCOPES_VERSION,
   SNIPPET_LINE_KEY,
+  computeScopes,
   debugIdFor,
   debugIdSnippet,
   findBundles,