@autter/runtime-cli 0.0.0-stage → 1.1.0

package/dist/index.cjs

@@ -0,0 +1,1079 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BUNDLE_RE: () => BUNDLE_RE,
+  DEBUG_ID_RE: () => DEBUG_ID_RE,
+  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,
+  formatUploadSummary: () => formatUploadSummary,
+  gitHead: () => gitHead,
+  hasDebugIdSnippet: () => hasDebugIdSnippet,
+  injectBundle: () => injectBundle,
+  injectDir: () => injectDir,
+  mapPathFor: () => mapPathFor,
+  normalizeDebugId: () => normalizeDebugId,
+  processBuildOutput: () => processBuildOutput,
+  readDebugIdComment: () => readDebugIdComment,
+  readSourceMappingUrl: () => readSourceMappingUrl,
+  resolveEndpoint: () => resolveEndpoint,
+  resolveRelease: () => resolveRelease,
+  servedFilename: () => servedFilename,
+  shiftMappings: () => shiftMappings,
+  snippetLine: () => snippetLine,
+  storedMapJson: () => storedMapJson,
+  stripSourceMappingUrl: () => stripSourceMappingUrl,
+  uploadDir: () => uploadDir
+});
+module.exports = __toCommonJS(src_exports);
+
+// 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/files.ts
+var import_node_fs = require("fs");
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+var BUNDLE_RE = /\.[cm]?js$/;
+var SOURCE_MAPPING_URL_RE = /^[ \t]*\/\/[#@] sourceMappingURL=([^\s'"]+)[ \t]*\r?$/gm;
+function readSourceMappingUrl(code) {
+  let found = null;
+  for (const match of code.matchAll(SOURCE_MAPPING_URL_RE)) found = match[1];
+  return found;
+}
+function stripSourceMappingUrl(code) {
+  const lines = code.split("\n");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i].trim();
+    if (line === "") continue;
+    if (/^\/\/[#@] sourceMappingURL=/.test(line)) {
+      lines.splice(i, 1);
+      return lines.join("\n");
+    }
+    if (!line.startsWith("//#")) break;
+  }
+  return code;
+}
+function mapPathFor(js, code) {
+  const url = readSourceMappingUrl(code);
+  if (url && !/^[a-z][\w+.-]*:/i.test(url) && !url.startsWith("/")) {
+    let decoded = url.split(/[?#]/)[0];
+    try {
+      decoded = decodeURIComponent(decoded);
+    } catch {
+    }
+    const candidate = (0, import_node_path.resolve)((0, import_node_path.dirname)(js), decoded);
+    if ((0, import_node_fs.existsSync)(candidate)) return candidate;
+  }
+  const sibling = `${js}.map`;
+  return (0, import_node_fs.existsSync)(sibling) ? sibling : null;
+}
+async function walk(dir, out, pattern = BUNDLE_RE) {
+  let entries;
+  try {
+    entries = await (0, import_promises.readdir)(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  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, 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 = [];
+  if (files) {
+    for (const file of files) if (BUNDLE_RE.test(file)) candidates.push((0, import_node_path.resolve)(root, file));
+  } else {
+    await walk(root, candidates);
+  }
+  const bundles = [];
+  for (const js of [...new Set(candidates)].sort()) {
+    let code;
+    try {
+      code = await (0, import_promises.readFile)(js, "utf8");
+    } catch {
+      continue;
+    }
+    const map = mapPathFor(js, code);
+    if (map) bundles.push({ js, map, path: (0, import_node_path.relative)(root, js).split(import_node_path.sep).join("/") });
+  }
+  return bundles;
+}
+
+// src/inject.ts
+var import_promises2 = require("fs/promises");
+var SNIPPET_LINE_KEY = "x_autter_snippet_line";
+function snippetLine(code) {
+  let line = 0;
+  let i = 0;
+  if (code.startsWith("#!")) {
+    const nl = code.indexOf("\n");
+    if (nl < 0) return -1;
+    line = 1;
+    i = nl + 1;
+  }
+  for (; ; ) {
+    while (i < code.length && /\s/.test(code[i])) i++;
+    if (code.startsWith("//", i)) {
+      const nl = code.indexOf("\n", i);
+      if (nl < 0) return -1;
+      i = nl + 1;
+    } else if (code.startsWith("/*", i)) {
+      const end = code.indexOf("*/", i + 2);
+      if (end < 0) return -1;
+      i = end + 2;
+    } else {
+      break;
+    }
+  }
+  return code[i] === '"' || code[i] === "'" ? -1 : line;
+}
+function shiftMappings(mappings, at, count = 1) {
+  const lines = mappings.split(";");
+  while (lines.length < at) lines.push("");
+  lines.splice(at, 0, ...Array(count).fill(""));
+  return lines.join(";");
+}
+function insertBeforeTrailingComments(code, text) {
+  const lines = code.split("\n");
+  let at = lines.length;
+  while (at > 0) {
+    const line = lines[at - 1].trim();
+    if (line === "" || line.startsWith("//#") || line.startsWith("//@")) at--;
+    else break;
+  }
+  const head = lines.slice(0, at).join("\n");
+  const tail = lines.slice(at).join("\n");
+  return `${head}${head && !head.endsWith("\n") ? "\n" : ""}${text}${tail ? `
+${tail.replace(/^\n+/, "")}` : "\n"}`;
+}
+async function injectBundle(bundle, options = {}) {
+  const bytes = await (0, import_promises2.readFile)(bundle.js);
+  const code = bytes.toString("utf8");
+  const base = { path: bundle.path, js: bundle.js, map: bundle.map };
+  let map;
+  try {
+    map = JSON.parse(await (0, import_promises2.readFile)(bundle.map, "utf8"));
+    if (!map || typeof map !== "object") throw new Error("not an object");
+  } catch {
+    return { ...base, debugId: "", status: "invalid-map" };
+  }
+  const existing = readDebugIdComment(code);
+  const hasSnippet = hasDebugIdSnippet(code);
+  const debugId = existing ?? debugIdFor(bytes);
+  let out = code;
+  let mapDirty = false;
+  if (!hasSnippet) {
+    const shifted = typeof map[SNIPPET_LINE_KEY] === "number" ? map[SNIPPET_LINE_KEY] : null;
+    const line = shifted ?? snippetLine(code);
+    if (line >= 0 && (shifted !== null || typeof map.mappings === "string" && !("sections" in map))) {
+      let offset = 0;
+      for (let n = 0; n < line; n++) offset = out.indexOf("\n", offset) + 1;
+      out = `${out.slice(0, offset)}${debugIdSnippet(debugId)}
+${out.slice(offset)}`;
+      if (shifted === null) {
+        map.mappings = shiftMappings(map.mappings, line);
+        map[SNIPPET_LINE_KEY] = line;
+        mapDirty = true;
+      }
+    } else {
+      out = insertBeforeTrailingComments(out, debugIdSnippet(debugId));
+    }
+  }
+  if (!existing) out = `${out}${out.endsWith("\n") ? "" : "\n"}//# debugId=${debugId}
+`;
+  if (options.stripSourceMappingUrl) out = stripSourceMappingUrl(out);
+  if (map.debugId !== debugId) {
+    map.debugId = debugId;
+    mapDirty = true;
+  }
+  const changed = mapDirty || out !== code;
+  if (changed && !options.dryRun) {
+    if (mapDirty) await (0, import_promises2.writeFile)(bundle.map, JSON.stringify(map));
+    if (out !== code) await (0, import_promises2.writeFile)(bundle.js, out);
+  }
+  return { ...base, debugId, status: changed ? "injected" : "unchanged" };
+}
+async function injectDir(dir, options = {}) {
+  const results = [];
+  for (const bundle of await findBundles(dir, options.files)) results.push(await injectBundle(bundle, options));
+  return results;
+}
+
+// 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");
+var RELEASE_RE = /^[a-zA-Z0-9._-]{1,200}$/;
+var RELEASE_ENV_VARS = [
+  "GITHUB_SHA",
+  "VERCEL_GIT_COMMIT_SHA",
+  "CF_PAGES_COMMIT_SHA",
+  "GIT_SHA"
+];
+function gitHead(cwd = process.cwd()) {
+  try {
+    const sha = (0, import_node_child_process.execFileSync)("git", ["rev-parse", "HEAD"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 1e4
+    }).trim();
+    return /^[0-9a-f]{7,64}$/.test(sha) ? sha : null;
+  } catch {
+    return null;
+  }
+}
+function resolveRelease(explicit, env = process.env, cwd = process.cwd()) {
+  const candidates = [
+    ["--release", explicit],
+    ...RELEASE_ENV_VARS.map((name) => [name, env[name]])
+  ];
+  for (const [source, value] of candidates) {
+    const release = value?.trim();
+    if (!release) continue;
+    if (!RELEASE_RE.test(release)) {
+      throw new Error(
+        `release "${release}" (from ${source}) is not valid: use 1-200 letters, digits, ".", "_" or "-" (a commit SHA works)`
+      );
+    }
+    return { release, source };
+  }
+  const head = gitHead(cwd);
+  if (head) return { release: head, source: "git" };
+  throw new Error(
+    `no release: pass --release <release>, or set one of ${RELEASE_ENV_VARS.join(", ")}, or run inside a git checkout`
+  );
+}
+
+// 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_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) {
+  const raw = flag || env.AUTTER_ENDPOINT || env.AUTTER_RUNTIME_ENDPOINT || env.OTEL_EXPORTER_OTLP_ENDPOINT || DEFAULT_ENDPOINT;
+  return raw.trim().replace(/\/+$/, "").replace(/\/v1\/[a-z-]+$/, "");
+}
+function servedFilename(urlPrefix, path) {
+  let prefix = (urlPrefix ?? "/").trim() || "/";
+  if (prefix.startsWith("~/")) prefix = prefix.slice(1);
+  if (!/^[a-z][\w+.-]*:\/\//i.test(prefix) && !prefix.startsWith("/")) prefix = `/${prefix}`;
+  return `${prefix.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
+}
+function storedMapJson(map) {
+  const { sourcesContent: _omitted, ...safe } = map;
+  return JSON.stringify(safe);
+}
+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"));
+  } catch {
+    return { error: "map is not valid JSON" };
+  }
+  if (!map || map.version !== 3 || typeof map.mappings !== "string" || !Array.isArray(map.sources)) {
+    return { error: "not a version 3 source map with mappings and sources" };
+  }
+  const code = await (0, import_promises3.readFile)(bundle.js, "utf8");
+  const debugId = readDebugIdComment(code) ?? normalizeDebugId(map.debugId);
+  const filename = servedFilename(urlPrefix, bundle.path);
+  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,
+    // 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),
+    mapChars: json.length
+  };
+}
+var FatalUploadError = class extends Error {
+};
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function uploadDir(dir, options = {}) {
+  const env = options.env ?? process.env;
+  const log = options.log ?? (() => {
+  });
+  const doFetch = options.fetch ?? fetch;
+  const { release, source: releaseSource } = resolveRelease(options.release, env, options.cwd);
+  const endpoint = resolveEndpoint(options.endpoint, env);
+  const summary = {
+    release,
+    releaseSource,
+    endpoint,
+    dryRun: Boolean(options.dryRun),
+    uploaded: [],
+    skipped: [],
+    failed: [],
+    legacyIngester: false,
+    deletedMaps: []
+  };
+  const items = [];
+  for (const bundle of await findBundles(dir, options.files)) {
+    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.mapChars > MAX_MAP_CHARS || prepared.bytes > MAX_UPLOAD_BYTES) {
+      summary.failed.push({
+        path: prepared.path,
+        filename: prepared.filename,
+        error: `map is ${(prepared.mapChars / 1048576).toFixed(1)} MB without sourcesContent; the ingester accepts up to 32 MB`
+      });
+    } else {
+      items.push(prepared);
+    }
+  }
+  if (options.dryRun) {
+    summary.uploaded = items.map(strip);
+    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)");
+  }
+  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);
+    try {
+      const res = await doFetch(`${endpoint}/v1/sourcemaps/check`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          release,
+          files: batch.map((item) => ({ filename: item.filename, ...item.debugId ? { debugId: item.debugId } : {}, hash: item.hash }))
+        })
+      });
+      if (res.status === 404) {
+        summary.legacyIngester = true;
+        log(
+          "warning: this ingester predates 1.6.0, so it stores no debug ids and rejects .mjs/.cjs maps. Upgrade it: docker pull ghcr.io/autter-dev/otlp-ingester:latest"
+        );
+        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.ok) throw new Error(`HTTP ${res.status}`);
+      const body = await res.json();
+      const present = new Set(Array.isArray(body.present) ? body.present : []);
+      batch.forEach((item, index) => {
+        if (present.has(index)) skipped.add(item);
+      });
+    } catch (err) {
+      if (err instanceof FatalUploadError) throw err;
+      log(`warning: could not check which maps the ingester already has (${err.message}); uploading all`);
+    }
+  }
+  const uploaded = [];
+  let fatal = null;
+  const uploadOne = async (item) => {
+    for (let attempt = 1; ; attempt++) {
+      if (fatal) return;
+      let status = 0;
+      let detail = "";
+      try {
+        const res = await doFetch(`${endpoint}/v1/sourcemaps`, { method: "POST", headers: uploadHeaders, body: item.body });
+        status = res.status;
+        if (res.ok) {
+          uploaded.push(item);
+          return;
+        }
+        detail = (await res.text()).slice(0, 300);
+      } catch (err) {
+        detail = err.message;
+      }
+      if (status === 401 || status === 403) {
+        fatal = new FatalUploadError(`the ingester rejected the key (${status}): ${detail}`);
+        return;
+      }
+      const retryable = status === 0 || status === 429 || status >= 500;
+      if (!retryable || attempt >= MAX_ATTEMPTS) {
+        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));
+    }
+  };
+  const queue = items.filter((item) => !skipped.has(item));
+  const workers = Array.from({ length: Math.max(1, Math.min(options.concurrency ?? 8, queue.length)) }, async () => {
+    for (let item = queue.shift(); item; item = queue.shift()) await uploadOne(item);
+  });
+  await Promise.all(workers);
+  if (fatal) throw fatal;
+  const order = (a, b) => items.indexOf(a) - items.indexOf(b);
+  uploaded.sort(order);
+  if (options.deleteAfterUpload) {
+    for (const item of [...uploaded, ...skipped]) {
+      await (0, import_promises3.rm)(item.bundle.map, { force: true });
+      const code = await (0, import_promises3.readFile)(item.bundle.js, "utf8");
+      const stripped = stripSourceMappingUrl(code);
+      if (stripped !== code) await (0, import_promises3.writeFile)(item.bundle.js, stripped);
+      summary.deletedMaps.push(item.bundle.map);
+    }
+  }
+  summary.uploaded = uploaded.map(strip);
+  summary.skipped = [...skipped].sort(order).map(strip);
+  return summary;
+}
+function strip(item) {
+  const { path, filename, debugId, hash, bytes } = item;
+  return { path, filename, debugId, hash, bytes };
+}
+
+// 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";
+  for (const item of summary.uploaded) {
+    lines.push(`${verb} ${item.filename}${item.debugId ? ` (debug id ${item.debugId})` : ""}`);
+  }
+  for (const item of summary.skipped) lines.push(`skipped ${item.filename} (already uploaded)`);
+  for (const item of summary.failed) lines.push(`failed ${item.filename}: ${item.error}`);
+  lines.push(
+    `${summary.uploaded.length} ${verb}, ${summary.skipped.length} already uploaded, ${summary.failed.length} failed (release ${summary.release} from ${summary.releaseSource}, ${summary.endpoint})`
+  );
+  return lines;
+}
+async function processBuildOutput(input) {
+  const { options } = input;
+  const log = (line) => {
+    if (!options.silent) console.log(`[autter-runtime] ${line}`);
+  };
+  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 {
+    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}`);
+    }
+  } 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}`);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BUNDLE_RE,
+  DEBUG_ID_RE,
+  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,
+  formatUploadSummary,
+  gitHead,
+  hasDebugIdSnippet,
+  injectBundle,
+  injectDir,
+  mapPathFor,
+  normalizeDebugId,
+  processBuildOutput,
+  readDebugIdComment,
+  readSourceMappingUrl,
+  resolveEndpoint,
+  resolveRelease,
+  servedFilename,
+  shiftMappings,
+  snippetLine,
+  storedMapJson,
+  stripSourceMappingUrl,
+  uploadDir
+});