@autter/runtime-cli 0.0.0-stage → 1.1.0

package/dist/cli.js

@@ -0,0 +1,1031 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { spawnSync } from "child_process";
+import { existsSync as existsSync3, readFileSync } from "fs";
+import { createRequire } from "module";
+import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
+import { parseArgs } from "util";
+
+// src/build.ts
+import { existsSync as existsSync2 } from "fs";
+import { relative as relative2, sep as sep2 } from "path";
+
+// src/files.ts
+import { existsSync } from "fs";
+import { readdir, readFile, rm, writeFile } from "fs/promises";
+import { dirname, join, relative, resolve, sep } from "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 = resolve(dirname(js), decoded);
+    if (existsSync(candidate)) return candidate;
+  }
+  const sibling = `${js}.map`;
+  return existsSync(sibling) ? sibling : null;
+}
+async function walk(dir, out, pattern = BUNDLE_RE) {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.name === "node_modules") continue;
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) await walk(full, out, pattern);
+    else if (entry.isFile() && pattern.test(entry.name)) out.push(full);
+  }
+}
+async function findBundles(dir, files) {
+  const root = resolve(dir);
+  const candidates = [];
+  if (files) {
+    for (const file of files) if (BUNDLE_RE.test(file)) candidates.push(resolve(root, file));
+  } else {
+    await walk(root, candidates);
+  }
+  const bundles = [];
+  for (const js of [...new Set(candidates)].sort()) {
+    let code;
+    try {
+      code = await readFile(js, "utf8");
+    } catch {
+      continue;
+    }
+    const map = mapPathFor(js, code);
+    if (map) bundles.push({ js, map, path: relative(root, js).split(sep).join("/") });
+  }
+  return bundles;
+}
+
+// src/inject.ts
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+
+// src/debug-id.ts
+import { createHash } from "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 = 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) {
+  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 readFile2(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 readFile2(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 writeFile2(bundle.map, JSON.stringify(map));
+    if (out !== code) await writeFile2(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
+import { createHash as createHash2 } from "crypto";
+import { readFile as readFile3, rm as rm2, writeFile as writeFile3 } from "fs/promises";
+import { promisify } from "util";
+import { gzip as gzipCallback } from "zlib";
+
+// src/release.ts
+import { execFileSync } from "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 = 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
+import { parse } from "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 parse(code, {
+      ...BASE_OPTIONS,
+      sourceType: "module",
+      allowAwaitOutsideFunction: true,
+      allowImportExportEverywhere: true
+    });
+  } catch (moduleError) {
+    try {
+      return 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 = promisify(gzipCallback);
+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 readFile3(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 readFile3(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: createHash2("sha256").update(json).digest("hex"),
+    bytes: Buffer.byteLength(body),
+    mapChars: json.length
+  };
+}
+var FatalUploadError = class extends Error {
+};
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, 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 rm2(item.bundle.map, { force: true });
+      const code = await readFile3(item.bundle.js, "utf8");
+      const stripped = stripSourceMappingUrl(code);
+      if (stripped !== code) await writeFile3(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
+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;
+}
+
+// src/cli.ts
+var USAGE = `autter-runtime \u2014 readable stack traces for Autter Runtime
+
+Usage:
+  autter-runtime sourcemaps inject <dir> [--dry-run]
+  autter-runtime sourcemaps upload <dir> [--release <r>] [--url-prefix <prefix>]
+                [--endpoint <url>] [--concurrency <n>] [--delete-after-upload] [--dry-run]
+  autter-runtime doctor ...      (provided by @autter/runtime-node)
+
+inject  Gives every .js/.mjs/.cjs bundle that has a source map a debug id
+        derived from its bytes: a "//# debugId=" comment, a one-line snippet
+        that registers it for @autter/runtime-browser, and "debugId" in the
+        .map. Running it again changes nothing.
+upload  Sends every map to <endpoint>/v1/sourcemaps with AUTTER_RUNTIME_KEY,
+        in parallel, skipping maps the ingester already has. Each map carries
+        the bundle's function scopes ("x_autter_scopes"), so stack frames are
+        named after the function they are in, not the call site.
+
+Options:
+  --release <r>          Default: $GITHUB_SHA, $VERCEL_GIT_COMMIT_SHA,
+                         $CF_PAGES_COMMIT_SHA, $GIT_SHA, then git rev-parse HEAD
+  --url-prefix <prefix>  Where <dir> is served from: "/" (default), "/static/",
+                         or "https://cdn.example.com/app/"
+  --endpoint <url>       Ingester base URL. Default: $AUTTER_ENDPOINT,
+                         $AUTTER_RUNTIME_ENDPOINT, $OTEL_EXPORTER_OTLP_ENDPOINT,
+                         then https://otlp.autter.dev
+  --concurrency <n>      Parallel uploads (default 8)
+  --delete-after-upload  Delete each .map once the ingester has it
+  --dry-run              Show what would change or be uploaded; write and send nothing
+  --json                 Print the result as JSON
+  -h, --help             Show this help
+  -v, --version          Print the version
+
+Environment:
+  AUTTER_RUNTIME_KEY     Server ingest key (autter_rt_\u2026), required by upload`;
+function ownVersion() {
+  try {
+    return JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+  } catch {
+    return "unknown";
+  }
+}
+function delegate(pkg, args) {
+  let manifest;
+  try {
+    manifest = createRequire(join2(process.cwd(), "package.json")).resolve(`${pkg}/package.json`);
+  } catch {
+    return null;
+  }
+  const bin = JSON.parse(readFileSync(manifest, "utf8")).bin;
+  const relative3 = typeof bin === "string" ? bin : bin?.["autter-runtime"];
+  if (!relative3) return null;
+  const script = resolve2(dirname2(manifest), relative3);
+  if (!existsSync3(script)) return null;
+  const result = spawnSync(process.execPath, [script, ...args], { stdio: "inherit" });
+  return result.status ?? 1;
+}
+var SOURCEMAPS_OPTIONS = {
+  release: { type: "string" },
+  "url-prefix": { type: "string" },
+  endpoint: { type: "string" },
+  concurrency: { type: "string" },
+  "delete-after-upload": { type: "boolean" },
+  "dry-run": { type: "boolean" },
+  json: { type: "boolean" },
+  help: { type: "boolean", short: "h" }
+};
+async function sourcemaps(argv) {
+  let parsed;
+  try {
+    parsed = parseArgs({ args: argv, allowPositionals: true, options: SOURCEMAPS_OPTIONS });
+  } catch (err) {
+    console.error(`${err.message}
+
+${USAGE}`);
+    return 64;
+  }
+  const { values, positionals } = parsed;
+  const [action, dir, ...extra] = positionals;
+  if (values.help) {
+    console.log(USAGE);
+    return 0;
+  }
+  if (action !== "inject" && action !== "upload" || !dir || extra.length) {
+    console.error(`${action && action !== "inject" && action !== "upload" ? `unknown command: sourcemaps ${action}
+
+` : ""}${USAGE}`);
+    return 64;
+  }
+  if (!existsSync3(dir)) {
+    console.error(`autter-runtime: ${dir} does not exist`);
+    return 64;
+  }
+  const dryRun = Boolean(values["dry-run"]);
+  if (action === "inject") {
+    const results = await injectDir(dir, { dryRun });
+    if (values.json) {
+      console.log(JSON.stringify(results.map(({ path, debugId, status }) => ({ path, debugId, status })), null, 2));
+    } else {
+      for (const r of results) {
+        const what = r.status === "invalid-map" ? "skipped (map is not valid JSON)" : r.status === "injected" ? dryRun ? "would inject" : "injected" : "unchanged";
+        console.log(`${what} ${r.path}${r.debugId ? ` ${r.debugId}` : ""}`);
+      }
+      const injected = results.filter((r) => r.status === "injected").length;
+      console.log(
+        results.length ? `${results.length} bundle(s) with source maps: ${injected} ${dryRun ? "would be injected" : "injected"}, ${results.length - injected} unchanged` : `no .js/.mjs/.cjs bundles with source maps under ${dir}`
+      );
+    }
+    return results.some((r) => r.status === "invalid-map") ? 1 : 0;
+  }
+  const concurrency = values.concurrency === void 0 ? void 0 : Number(values.concurrency);
+  if (concurrency !== void 0 && (!Number.isInteger(concurrency) || concurrency < 1)) {
+    console.error("autter-runtime: --concurrency must be a positive integer");
+    return 64;
+  }
+  const summary = await uploadDir(dir, {
+    release: values.release,
+    urlPrefix: values["url-prefix"],
+    endpoint: values.endpoint,
+    concurrency,
+    dryRun,
+    deleteAfterUpload: Boolean(values["delete-after-upload"]),
+    log: (line) => console.error(line)
+  });
+  if (values.json) console.log(JSON.stringify(summary, null, 2));
+  else {
+    if (!summary.uploaded.length && !summary.skipped.length && !summary.failed.length) {
+      console.log(`no .js/.mjs/.cjs bundles with source maps under ${dir}`);
+    }
+    for (const line of formatUploadSummary(summary)) console.log(line);
+  }
+  return summary.failed.length ? 1 : 0;
+}
+async function main(argv) {
+  const [command, ...rest] = argv;
+  if (command === "-v" || command === "--version") {
+    console.log(ownVersion());
+    return 0;
+  }
+  if (command === void 0 || command === "-h" || command === "--help" || command === "help") {
+    console.log(USAGE);
+    return 0;
+  }
+  if (command === "sourcemaps") return sourcemaps(rest);
+  if (command === "doctor") {
+    const code = delegate("@autter/runtime-node", argv);
+    if (code !== null) return code;
+    console.error("autter-runtime doctor is part of @autter/runtime-node: npx @autter/runtime-node doctor");
+    return 64;
+  }
+  console.error(`unknown command: ${command}
+
+${USAGE}`);
+  return 64;
+}
+main(process.argv.slice(2)).then(
+  (code) => {
+    process.exitCode = code;
+  },
+  (err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`autter-runtime: ${message}`);
+    process.exitCode = 2;
+  }
+);