@getargus/build-tools 0.0.0-stage → 0.3.0

package/dist/index.cjs

@@ -0,0 +1,1548 @@
+"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, {
+  ARTIFACT_SET_GLOBAL: () => ARTIFACT_SET_GLOBAL,
+  NEXT_PUBLIC_ENV: () => NEXT_PUBLIC_ENV,
+  NEXT_SERVER_ENV: () => NEXT_SERVER_ENV,
+  applyInit: () => applyInit,
+  artifactSetPrelude: () => artifactSetPrelude,
+  assertArtifactSetId: () => assertArtifactSetId,
+  browserSourceMaps: () => browserSourceMaps,
+  buildManifest: () => buildManifest,
+  classifyArtifact: () => classifyArtifact,
+  detectPackageManager: () => detectPackageManager,
+  detectProject: () => detectProject,
+  formatCommand: () => formatCommand,
+  injectArtifactSetId: () => injectArtifactSetId,
+  isJsOnlyPlan: () => isJsOnlyPlan,
+  isValidArtifactSetId: () => isValidArtifactSetId,
+  manifestName: () => manifestName,
+  newArtifactSetId: () => newArtifactSetId,
+  nextArtifactSetIds: () => nextArtifactSetIds,
+  nextUrlPrefix: () => nextUrlPrefix,
+  planExpoExport: () => planExpoExport,
+  planFiles: () => planFiles,
+  planInit: () => planInit,
+  planNative: () => planNative,
+  planNext: () => planNext,
+  renderInit: () => renderInit,
+  resolveArtifactSetId: () => resolveArtifactSetId,
+  runCli: () => main,
+  runInit: () => runInit,
+  runUploads: () => runUploads,
+  uploadArgs: () => uploadArgs,
+  uploadNextBuild: () => uploadNextBuild,
+  uploadPlanOverHttp: () => uploadPlanOverHttp,
+  walkFiles: () => walkFiles,
+  withArgusMetro: () => withArgus,
+  withArgusNext: () => withArgus2,
+  writeArtifactSetModule: () => writeArtifactSetModule
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/ids.ts
+var import_node_crypto = require("crypto");
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var ARTIFACT_SET_GLOBAL = "__ARGUS_ARTIFACT_SET_ID__";
+var NEXT_PUBLIC_ENV = "NEXT_PUBLIC_ARGUS_ARTIFACT_SET_ID";
+var NEXT_SERVER_ENV = "ARGUS_SERVER_ARTIFACT_SET_ID";
+var RE_ARTIFACT_SET_ID = /^[A-Za-z0-9._:-]{1,128}$/;
+var GENERATED_MARK = "/* generated by @getargus/build-tools \u2014 do not edit, do not commit */";
+function isValidArtifactSetId(id) {
+  return typeof id === "string" && RE_ARTIFACT_SET_ID.test(id);
+}
+function assertArtifactSetId(id, what = "artifact set id") {
+  if (!isValidArtifactSetId(id)) {
+    throw new Error(`Argus: invalid ${what} ${JSON.stringify(id)} \u2014 expected 1..128 chars of [A-Za-z0-9._:-]`);
+  }
+  return id;
+}
+function newArtifactSetId(prefix = "build", now = Date.now()) {
+  const clean = Array.from(String(prefix)).filter((c) => /[A-Za-z0-9._-]/.test(c)).slice(0, 80).join("");
+  const b = (0, import_node_crypto.randomBytes)(16);
+  b.writeUIntBE(now, 0, 6);
+  b[6] = b[6] & 15 | 112;
+  b[8] = b[8] & 63 | 128;
+  return `${clean || "build"}-${b.toString("hex")}`;
+}
+function resolveArtifactSetId(input, platform, env = process.env) {
+  const fromEnv = env[`ARGUS_ARTIFACT_SET_ID_${platform.toUpperCase()}`] || env.ARGUS_ARTIFACT_SET_ID;
+  const fromOption = typeof input === "function" ? input(platform) : typeof input === "string" ? input : input?.[platform];
+  const id = fromEnv || fromOption;
+  return id ? assertArtifactSetId(id, `artifact set id for ${platform}`) : void 0;
+}
+function artifactSetPrelude(artifactSetId) {
+  const id = JSON.stringify(assertArtifactSetId(artifactSetId));
+  return `${GENERATED_MARK}
+(function (g) {
+  g.${ARTIFACT_SET_GLOBAL} = ${id};
+})(
+  typeof globalThis !== 'undefined' ? globalThis : typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : this,
+);
+`;
+}
+function writeArtifactSetModule(options) {
+  const file = (0, import_node_path.resolve)(options.file);
+  const content = artifactSetPrelude(options.artifactSetId);
+  if ((0, import_node_fs.existsSync)(file)) {
+    const current = (0, import_node_fs.readFileSync)(file, "utf8");
+    if (current === content) return { file, changed: false };
+    if (!current.startsWith(GENERATED_MARK)) {
+      throw new Error(`Argus: refusing to overwrite ${file}: it was not generated by @getargus/build-tools (built output is never patched)`);
+    }
+  }
+  (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(file), { recursive: true });
+  (0, import_node_fs.writeFileSync)(file, content);
+  return { file, changed: true };
+}
+var injectArtifactSetId = writeArtifactSetModule;
+
+// src/metro.ts
+var import_node_module = require("module");
+var import_node_path2 = require("path");
+var PLATFORMS = ["ios", "android", "web"];
+function withArgus(metroConfig, options = {}) {
+  const projectRoot = (0, import_node_path2.resolve)(options.projectRoot ?? metroConfig.projectRoot ?? process.cwd());
+  const outDir = (0, import_node_path2.resolve)(options.outDir ?? (0, import_node_path2.join)(projectRoot, ".argus"));
+  const env = options.env ?? process.env;
+  const files = {};
+  for (const platform of PLATFORMS) {
+    const id = resolveArtifactSetId(options.artifactSetId, platform, env);
+    if (id) files[platform] = writeArtifactSetModule({ file: (0, import_node_path2.join)(outDir, `argus-artifact-set.${platform}.js`), artifactSetId: id }).file;
+  }
+  const previous = metroConfig.serializer?.getPolyfills;
+  const warned = /* @__PURE__ */ new Set();
+  const basePolyfills = (ctx) => {
+    if (typeof previous === "function") return previous(ctx);
+    try {
+      const rnPolyfills = (0, import_node_module.createRequire)((0, import_node_path2.join)(projectRoot, "package.json"))("@react-native/js-polyfills");
+      return rnPolyfills();
+    } catch {
+      return [];
+    }
+  };
+  const getPolyfills = (ctx) => {
+    const base = basePolyfills(ctx);
+    const platform = String(ctx?.platform ?? "");
+    const file = files[platform];
+    if (!file) {
+      if (!warned.has(platform)) {
+        warned.add(platform);
+        (options.onMissing ?? ((p) => console.warn(`[argus] no artifact set id for platform "${p}": this bundle will not be matched to its source map (set ARGUS_ARTIFACT_SET_ID${p ? `_${p.toUpperCase()}` : ""})`)))(platform);
+      }
+      return base;
+    }
+    return [...base, file];
+  };
+  return { ...metroConfig, serializer: { ...metroConfig.serializer, getPolyfills } };
+}
+
+// src/next.ts
+var import_node_module2 = require("module");
+var import_node_path5 = require("path");
+
+// src/next-upload.ts
+var import_node_fs4 = require("fs");
+
+// src/collect.ts
+var import_node_fs2 = require("fs");
+var import_node_path3 = require("path");
+function classifyArtifact(path) {
+  const lower = (0, import_node_path3.basename)(path).toLowerCase();
+  if (lower.endsWith(".map")) return "sourcemap";
+  if (lower === "mapping.txt" || lower.endsWith(".mapping.txt")) return "proguard";
+  if (lower.endsWith(".so") || lower.endsWith(".so.dbg")) return "elf";
+  const parts = path.split(/[\\/]/);
+  if (parts.includes("DWARF") && parts.some((p) => p.endsWith(".dSYM"))) return "dsym";
+  if (/\.(js|mjs|cjs|bundle|jsbundle|hbc)$/.test(lower)) return "js_bundle";
+  return void 0;
+}
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "cache", ".cache", "Pods"]);
+function walkFiles(dir, opts = {}) {
+  const skip = opts.skipDirs ?? SKIP_DIRS;
+  const out = [];
+  const visit = (d) => {
+    let entries;
+    try {
+      entries = (0, import_node_fs2.readdirSync)(d, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0)) {
+      const p = (0, import_node_path3.join)(d, e.name);
+      if (e.isDirectory()) {
+        if (!skip.has(e.name)) visit(p);
+      } else if (e.isFile()) out.push(p);
+    }
+  };
+  visit(dir);
+  return out;
+}
+function describe(paths) {
+  const out = [];
+  for (const p of paths) {
+    const files = (0, import_node_fs2.statSync)(p).isDirectory() ? walkFiles(p, { skipDirs: /* @__PURE__ */ new Set() }) : [p];
+    for (const f of files) {
+      const kind = classifyArtifact(f);
+      if (kind) out.push({ path: f, kind, size: (0, import_node_fs2.statSync)(f).size });
+    }
+  }
+  return out;
+}
+function meta(m) {
+  const out = {};
+  for (const k of ["release", "dist", "nativeRelease", "nativeBuild", "runtimeVersion", "gitSha"]) {
+    if (m[k]) out[k] = m[k];
+  }
+  return out;
+}
+var RE_JS = /\.(js|mjs|cjs|bundle|jsbundle|hbc)$/;
+var RE_JS_MAP = /\.(js|mjs|cjs|bundle|jsbundle|hbc)\.map$/;
+function referencedMap(file) {
+  let tail = "";
+  try {
+    const size = (0, import_node_fs2.statSync)(file).size;
+    const buf = Buffer.alloc(Math.min(size, 1024));
+    const fd = (0, import_node_fs2.openSync)(file, "r");
+    try {
+      (0, import_node_fs2.readSync)(fd, buf, 0, buf.length, size - buf.length);
+    } finally {
+      (0, import_node_fs2.closeSync)(fd);
+    }
+    tail = buf.toString("utf8");
+  } catch {
+    return void 0;
+  }
+  const ref = /\/\/[#@] sourceMappingURL=([^\s'"]+)\s*$/.exec(tail)?.[1];
+  if (!ref || /^[a-z][a-z0-9+.-]*:/i.test(ref)) return void 0;
+  return (0, import_node_path3.resolve)((0, import_node_path3.dirname)(file), ref.split(/[?#]/)[0]);
+}
+function jsPairs(dir, includeBundles, warnings, label) {
+  const files = walkFiles(dir);
+  const set = new Set(files);
+  const orphans = new Set(files.filter((f) => RE_JS_MAP.test(f.toLowerCase()) && !set.has(f.slice(0, -4))));
+  const generatedFor = {};
+  const referenced = /* @__PURE__ */ new Set();
+  if (orphans.size > 0) {
+    for (const f of files) {
+      if (!RE_JS.test(f.toLowerCase()) || set.has(`${f}.map`)) continue;
+      const map = referencedMap(f);
+      if (map && orphans.has(map) && !generatedFor[map]) {
+        generatedFor[map] = f;
+        referenced.add(f);
+      }
+    }
+  }
+  const out = [];
+  let unmapped = 0;
+  for (const f of files) {
+    const lower = f.toLowerCase();
+    if (RE_JS_MAP.test(lower)) {
+      const generated = generatedFor[f] ?? (set.has(f.slice(0, -4)) ? f.slice(0, -4) : void 0);
+      if (!generated) warnings.push(`${label}: ${f} has no generated file next to it`);
+      out.push(f);
+      if (includeBundles && generated) out.push(generated);
+    } else if (RE_JS.test(lower) && !set.has(`${f}.map`) && !referenced.has(f)) unmapped++;
+  }
+  if (unmapped > 0) warnings.push(`${label}: ${unmapped} JS file(s) without a source map were skipped`);
+  return { paths: [...new Set(out)].sort(), generatedFor };
+}
+var NO_PAIRS = { paths: [], generatedFor: {} };
+var renamed = (pairs) => Object.keys(pairs.generatedFor).length > 0 ? { generatedFor: pairs.generatedFor } : {};
+function planNext(options) {
+  const projectDir = (0, import_node_path3.resolve)(options.projectDir ?? process.cwd());
+  const dist = (0, import_node_path3.resolve)(projectDir, options.distDir ?? ".next");
+  if (!(0, import_node_fs2.existsSync)(dist)) throw new Error(`Argus: Next build output not found at ${dist} (run \`next build\` first)`);
+  const web = assertArtifactSetId(options.artifactSetId);
+  const node = assertArtifactSetId(options.serverArtifactSetId ?? `${web}-node`, "server artifact set id");
+  if (web === node) throw new Error("Argus: browser and server chunks must use different artifact set ids");
+  const include = options.includeBundles !== false;
+  const plans = [];
+  const notes = [];
+  const browserWarnings = [];
+  const browser = (0, import_node_fs2.existsSync)((0, import_node_path3.join)(dist, "static")) ? jsPairs((0, import_node_path3.join)(dist, "static"), include, browserWarnings, "next:browser") : NO_PAIRS;
+  if (browser.paths.some((f) => f.endsWith(".map"))) {
+    plans.push({
+      label: "next:browser",
+      artifactSetId: web,
+      platform: "web",
+      paths: browser.paths,
+      files: describe(browser.paths),
+      stripPrefix: dist,
+      urlPrefix: options.urlPrefix ?? "/_next/",
+      ...renamed(browser),
+      ...meta(options),
+      warnings: browserWarnings
+    });
+  } else notes.push("next:browser: no source maps under static/ (is productionBrowserSourceMaps enabled?)");
+  const serverWarnings = [];
+  const server = (0, import_node_fs2.existsSync)((0, import_node_path3.join)(dist, "server")) ? jsPairs((0, import_node_path3.join)(dist, "server"), include, serverWarnings, "next:server") : NO_PAIRS;
+  if (server.paths.some((f) => f.endsWith(".map"))) {
+    plans.push({
+      label: "next:server",
+      artifactSetId: node,
+      platform: "node",
+      paths: server.paths,
+      files: describe(server.paths),
+      // Server frames are filesystem paths ending in `.next/server/...`.
+      stripPrefix: projectDir,
+      urlPrefix: "",
+      ...renamed(server),
+      ...meta(options),
+      warnings: serverWarnings
+    });
+  } else notes.push("next:server: no source maps under server/ (server source maps are not emitted by default)");
+  if (plans.length === 0) throw new Error(`Argus: no source maps found in ${dist}. ${notes.join("; ")}`);
+  plans[0].warnings.push(...notes);
+  return plans;
+}
+function browserSourceMaps(projectDir, distDir = ".next") {
+  const dir = (0, import_node_path3.resolve)(projectDir, distDir, "static");
+  return (0, import_node_fs2.existsSync)(dir) ? walkFiles(dir).filter((f) => f.endsWith(".map")) : [];
+}
+function str(v) {
+  return typeof v === "string" && v ? v : void 0;
+}
+function planExpoExport(options) {
+  const dir = (0, import_node_path3.resolve)(options.exportDir ?? "dist");
+  const metadataPath = (0, import_node_path3.join)(dir, "metadata.json");
+  if (!(0, import_node_fs2.existsSync)(metadataPath)) throw new Error(`Argus: ${metadataPath} not found (run \`expo export\` first)`);
+  const metadata = JSON.parse((0, import_node_fs2.readFileSync)(metadataPath, "utf8"));
+  const available = Object.keys(metadata.fileMetadata ?? {}).filter((p) => p === "ios" || p === "android");
+  const wanted = options.platforms ?? available.filter((p) => options.artifactSetIds[p]);
+  if (wanted.length === 0) throw new Error("Argus: no platform to upload \u2014 pass an artifact set id for ios and/or android");
+  const ids = wanted.map((p) => options.artifactSetIds[p]);
+  if (new Set(ids).size !== ids.length) throw new Error("Argus: iOS and Android updates need different artifact set ids");
+  const plans = [];
+  for (const platform of wanted) {
+    const label = `expo-export:${platform}`;
+    const artifactSetId = assertArtifactSetId(options.artifactSetIds[platform], `artifact set id for ${platform}`);
+    const entry = metadata.fileMetadata?.[platform];
+    const bundleRel = str(entry?.bundle);
+    if (!bundleRel) throw new Error(`Argus: metadata.json has no bundle for ${platform}`);
+    const bundle = (0, import_node_path3.resolve)(dir, bundleRel);
+    if (!bundle.startsWith(dir + import_node_path3.sep)) throw new Error(`Argus: metadata.json bundle path escapes the export directory: ${bundleRel}`);
+    const map = `${bundle}.map`;
+    if (!(0, import_node_fs2.existsSync)(bundle)) throw new Error(`Argus: ${bundle} is missing`);
+    if (!(0, import_node_fs2.existsSync)(map)) throw new Error(`Argus: ${map} is missing \u2014 export with source maps (\`expo export --dump-sourcemap\`)`);
+    const warnings = [];
+    const given = typeof options.updateId === "string" ? wanted.length === 1 ? options.updateId : void 0 : options.updateId?.[platform];
+    if (typeof options.updateId === "string" && wanted.length > 1) warnings.push(`${label}: a single --update-id cannot apply to several platforms; pass one per platform`);
+    const updateId = given ?? str(entry?.updateId) ?? str(entry?.id) ?? str(metadata.updateId) ?? str(metadata.id);
+    if (!updateId) warnings.push(`${label}: no update id (not in metadata.json, none given) \u2014 the set is still matched by artifact_set_id`);
+    const parentSetId = options.parentSetIds?.[platform];
+    if (!parentSetId) warnings.push(`${label}: no parent set id \u2014 native frames of crashes during this update cannot be tied to the native build's symbols`);
+    const paths = [bundle, map];
+    plans.push({
+      label,
+      artifactSetId,
+      platform,
+      paths,
+      files: describe(paths),
+      // Named by file name: `entry-<hash>.hbc` ← `entry-<hash>.hbc.map`.
+      stripPrefix: (0, import_node_path3.dirname)(bundle),
+      urlPrefix: "",
+      ota: true,
+      updateId,
+      parentSetId: parentSetId ? assertArtifactSetId(parentSetId, `parent set id for ${platform}`) : void 0,
+      ...meta(options),
+      warnings
+    });
+  }
+  return plans;
+}
+function findDsyms(root) {
+  const out = [];
+  const visit = (d, depth) => {
+    if (depth > 12) return;
+    let entries;
+    try {
+      entries = (0, import_node_fs2.readdirSync)(d, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (!e.isDirectory() || e.name === "node_modules" || e.name === ".git") continue;
+      const p = (0, import_node_path3.join)(d, e.name);
+      if (e.name.endsWith(".dSYM")) out.push(p);
+      else visit(p, depth + 1);
+    }
+  };
+  if (root.endsWith(".dSYM")) out.push(root);
+  else visit(root, 0);
+  return out.sort();
+}
+function planNative(options) {
+  const label = `native:${options.platform}`;
+  const artifactSetId = assertArtifactSetId(options.artifactSetId);
+  const warnings = [];
+  const paths = /* @__PURE__ */ new Set();
+  const roots = options.searchPaths.map((p) => (0, import_node_path3.resolve)(p));
+  for (const root of roots) if (!(0, import_node_fs2.existsSync)(root)) throw new Error(`Argus: ${root} does not exist`);
+  const jsMaps = [];
+  for (const root of roots) {
+    const isDir2 = (0, import_node_fs2.statSync)(root).isDirectory();
+    if (options.platform === "ios") {
+      if (isDir2) for (const d of findDsyms(root)) paths.add(d);
+    }
+    const files2 = isDir2 ? root.endsWith(".dSYM") ? [] : walkFiles(root, { skipDirs: /* @__PURE__ */ new Set(["node_modules", ".git", "Pods"]) }) : [root];
+    for (const f of files2) {
+      const name = (0, import_node_path3.basename)(f).toLowerCase();
+      if (f.split(import_node_path3.sep).some((part) => part.endsWith(".dSYM"))) continue;
+      if (options.platform === "android") {
+        if (name === "mapping.txt") paths.add(f);
+        else if (options.includeNativeLibs && name.endsWith(".so")) paths.add(f);
+      }
+      if (/\.(jsbundle|bundle)\.map$/.test(name)) jsMaps.push(f);
+    }
+  }
+  if (options.sourcemap) jsMaps.unshift((0, import_node_path3.resolve)(options.sourcemap));
+  const uniqueMaps = [...new Set(jsMaps)];
+  if (uniqueMaps.length > 1 && !options.sourcemap) {
+    warnings.push(`${label}: several JS source maps found, using ${uniqueMaps[0]} (pass --sourcemap to choose): ${uniqueMaps.slice(1).join(", ")}`);
+  }
+  const map = uniqueMaps[0];
+  if (map) {
+    if (!(0, import_node_fs2.existsSync)(map)) throw new Error(`Argus: ${map} does not exist`);
+    paths.add(map);
+    const bundle = options.bundle ? (0, import_node_path3.resolve)(options.bundle) : map.slice(0, -4);
+    if ((0, import_node_fs2.existsSync)(bundle)) {
+      if ((0, import_node_path3.basename)(bundle) !== (0, import_node_path3.basename)(map).slice(0, -4)) {
+        warnings.push(`${label}: bundle ${(0, import_node_path3.basename)(bundle)} and map ${(0, import_node_path3.basename)(map)} have different names; frames are matched against "${(0, import_node_path3.basename)(map).slice(0, -4)}"`);
+      }
+      paths.add(bundle);
+    }
+  } else warnings.push(`${label}: no JS source map found (*.bundle.map / *.jsbundle.map) \u2014 JS frames of this build will stay unsymbolicated`);
+  const list = [...paths].sort();
+  const files = describe(list);
+  if (options.platform === "ios" && !files.some((f) => f.kind === "dsym")) warnings.push(`${label}: no .dSYM found \u2014 native iOS frames will stay unsymbolicated`);
+  if (options.platform === "android") {
+    const mappings = files.filter((f) => f.kind === "proguard");
+    if (mappings.length === 0) warnings.push(`${label}: no mapping.txt found \u2014 fine only if R8/ProGuard is disabled for this build`);
+    if (mappings.length > 1) throw new Error(`Argus: several mapping.txt files found (${mappings.map((m) => m.path).join(", ")}); point --dir at one build variant`);
+  }
+  if (list.length === 0) throw new Error(`Argus: nothing to upload for ${label} under ${roots.join(", ")}`);
+  return { label, artifactSetId, platform: options.platform, paths: list, files, ...meta(options), warnings };
+}
+function planFiles(options) {
+  const label = `files:${options.platform}`;
+  const warnings = [];
+  const paths = [];
+  const generatedFor = {};
+  for (const p of options.paths.map((x) => (0, import_node_path3.resolve)(x))) {
+    if (!(0, import_node_fs2.existsSync)(p)) throw new Error(`Argus: ${p} does not exist`);
+    if ((0, import_node_fs2.statSync)(p).isDirectory()) {
+      const pairs = jsPairs(p, options.includeBundles !== false, warnings, label);
+      paths.push(...pairs.paths);
+      Object.assign(generatedFor, pairs.generatedFor);
+    } else paths.push(p);
+  }
+  const unique = [...new Set(paths)].sort();
+  if (unique.length === 0) throw new Error(`Argus: no artifacts found in ${options.paths.join(", ")}`);
+  const plan = {
+    label,
+    artifactSetId: assertArtifactSetId(options.artifactSetId),
+    platform: options.platform,
+    paths: unique,
+    files: describe(unique),
+    ...meta(options),
+    warnings
+  };
+  if (options.stripPrefix !== void 0) plan.stripPrefix = (0, import_node_path3.resolve)(options.stripPrefix);
+  if (options.urlPrefix !== void 0) plan.urlPrefix = options.urlPrefix;
+  if (Object.keys(generatedFor).length > 0) plan.generatedFor = generatedFor;
+  return plan;
+}
+function uploadArgs(plan, opts = {}) {
+  const args = ["artifacts", "upload", "--set-id", plan.artifactSetId, "--platform", plan.platform];
+  const flag = (name, value) => {
+    if (value !== void 0 && value !== "") args.push(name, value);
+  };
+  flag("--url", opts.url);
+  flag("--release", plan.release);
+  flag("--dist", plan.dist);
+  flag("--native-release", plan.nativeRelease);
+  flag("--native-build", plan.nativeBuild);
+  flag("--runtime-version", plan.runtimeVersion);
+  if (plan.ota) args.push("--ota");
+  flag("--update-id", plan.updateId);
+  flag("--parent-set-id", plan.parentSetId);
+  flag("--git-sha", plan.gitSha);
+  flag("--strip-prefix", plan.stripPrefix);
+  flag("--url-prefix", plan.urlPrefix);
+  if (opts.dryRun) args.push("--dry-run");
+  args.push("--", ...plan.paths);
+  return args;
+}
+function manifestName(plan, file) {
+  const generated = file.endsWith(".map") ? plan.generatedFor?.[file] ?? file.slice(0, -4) : file;
+  const prefix = plan.stripPrefix;
+  const rel = prefix && (generated === prefix || generated.startsWith(prefix.endsWith(import_node_path3.sep) ? prefix : prefix + import_node_path3.sep)) ? (0, import_node_path3.relative)(prefix, generated) : (0, import_node_path3.basename)(generated);
+  return `${plan.urlPrefix ?? ""}${rel.split(import_node_path3.sep).join("/").replace(/^\/+/, "")}`;
+}
+function formatCommand(bin, args, cwd = process.cwd()) {
+  const quote = (s2) => /^[A-Za-z0-9_./:@=+-]+$/.test(s2) ? s2 : `'${s2.replace(/'/g, `'\\''`)}'`;
+  const short = (s2) => {
+    if (!s2.startsWith(cwd + import_node_path3.sep)) return s2;
+    return (0, import_node_path3.relative)(cwd, s2);
+  };
+  return [bin, ...args.map((a) => quote(short(a)))].join(" ");
+}
+
+// src/upload.ts
+var import_node_child_process = require("child_process");
+
+// src/http-upload.ts
+var import_node_crypto2 = require("crypto");
+var import_node_fs3 = require("fs");
+var import_node_path4 = require("path");
+var NATIVE_KINDS = /* @__PURE__ */ new Set(["dsym", "elf", "proguard"]);
+function isJsOnlyPlan(plan) {
+  return plan.files.length > 0 && plan.files.every((f) => !NATIVE_KINDS.has(f.kind));
+}
+function sha256File(path) {
+  return new Promise((resolvePromise, reject) => {
+    const hash = (0, import_node_crypto2.createHash)("sha256");
+    (0, import_node_fs3.createReadStream)(path).on("data", (chunk) => hash.update(chunk)).on("error", reject).on("end", () => resolvePromise(hash.digest("hex")));
+  });
+}
+function isHermesMap(path) {
+  const needle = "x_facebook_sources";
+  const head = Buffer.alloc(256 * 1024);
+  const fd = (0, import_node_fs3.openSync)(path, "r");
+  let n = 0;
+  try {
+    n = (0, import_node_fs3.readSync)(fd, head, 0, head.length, 0);
+  } finally {
+    (0, import_node_fs3.closeSync)(fd);
+  }
+  if (head.subarray(0, n).includes(needle)) return true;
+  return (0, import_node_fs3.statSync)(path).size > n && (0, import_node_fs3.readFileSync)(path).includes(needle);
+}
+function setName(plan, file) {
+  const prefix = plan.stripPrefix;
+  const inside = prefix && (file === prefix || file.startsWith(prefix.endsWith(import_node_path4.sep) ? prefix : prefix + import_node_path4.sep));
+  return (inside ? (0, import_node_path4.relative)(prefix, file) : file).split(import_node_path4.sep).join("/").replace(/^\/+/, "");
+}
+async function buildManifest(plan) {
+  const found = [];
+  const paths = [...new Set(plan.files.map((f) => f.path))].sort();
+  for (const path of paths) {
+    const kind = plan.files.find((f) => f.path === path).kind;
+    if (NATIVE_KINDS.has(kind)) throw new Error(`Argus: ${(0, import_node_path4.basename)(path)} is a native symbol file; upload it with the argus CLI`);
+    const size = (0, import_node_fs3.statSync)(path).size;
+    if (size === 0) throw new Error(`Argus: ${path} is empty`);
+    const sha256 = await sha256File(path);
+    if (kind === "sourcemap") {
+      found.push({
+        path,
+        file: { kind: isHermesMap(path) ? "hermes_sourcemap" : "sourcemap", name: setName(plan, path), bundle_name: manifestName(plan, path), sha256, size }
+      });
+    } else {
+      found.push({ path, file: { kind: "js_bundle", name: manifestName(plan, path), sha256, size } });
+    }
+  }
+  found.sort((a, b) => a.file.name < b.file.name ? -1 : a.file.name > b.file.name ? 1 : 0);
+  const unique = found.filter((f, i) => i === 0 || found[i - 1].file.name !== f.file.name);
+  if (unique.length === 0) throw new Error("Argus: no artifacts found in the given paths");
+  const manifest = {
+    schema_version: 1,
+    artifact_set_id: plan.artifactSetId,
+    platform: plan.platform,
+    is_embedded: !plan.ota,
+    files: unique.map((f) => f.file)
+  };
+  const set = (key, value) => {
+    if (value !== void 0 && value !== "") manifest[key] = value;
+  };
+  set("release", plan.release);
+  set("dist", plan.dist);
+  set("native_release", plan.nativeRelease);
+  set("native_build", plan.nativeBuild);
+  set("runtime_version", plan.runtimeVersion);
+  set("update_id", plan.updateId);
+  set("git_sha", plan.gitSha);
+  set("parent_artifact_set_id", plan.parentSetId);
+  return { manifest, found: unique };
+}
+var defaultFetch = async (url, init) => {
+  const res = await fetch(url, init);
+  return { status: res.status, text: () => res.text() };
+};
+async function call(doFetch, method, url, key, body) {
+  const headers = { authorization: `Bearer ${key}` };
+  let payload;
+  if (body?.json !== void 0) {
+    headers["content-type"] = "application/json";
+    payload = JSON.stringify(body.json);
+  } else if (body?.bytes) {
+    headers["content-type"] = "application/octet-stream";
+    payload = body.bytes;
+  }
+  const init = { method, headers };
+  if (payload !== void 0) init.body = payload;
+  let res;
+  try {
+    res = await doFetch(url, init);
+  } catch (e) {
+    throw new Error(`Argus: cannot reach ${new URL(url).origin} (${e instanceof Error ? e.message : String(e)})`);
+  }
+  const text = await res.text();
+  let parsed;
+  try {
+    parsed = text ? JSON.parse(text) : {};
+  } catch {
+    parsed = void 0;
+  }
+  if (res.status < 200 || res.status >= 300) {
+    const detail = parsed && typeof parsed === "object" ? JSON.stringify(parsed) : text.slice(0, 300);
+    throw new Error(`Argus: ${method} ${new URL(url).pathname} \u2192 HTTP ${res.status} ${detail}`);
+  }
+  if (!parsed || typeof parsed !== "object") throw new Error(`Argus: ${method} ${new URL(url).pathname} did not return JSON (is ARGUS_URL the server's base URL?)`);
+  return parsed;
+}
+async function uploadPlanOverHttp(plan, options) {
+  const log = options.log ?? ((line) => console.error(line));
+  const { manifest, found } = await buildManifest(plan);
+  if (options.dryRun) {
+    log(JSON.stringify(manifest, null, 2));
+    return { status: "dry_run", uploaded: 0, files: found.length };
+  }
+  const base = options.url.replace(/\/+$/, "");
+  if (!/^https?:\/\//i.test(base)) throw new Error("Argus: ARGUS_URL must be the server base URL (https://host)");
+  const doFetch = options.fetch ?? defaultFetch;
+  const id = encodeURIComponent(plan.artifactSetId);
+  const created = await call(doFetch, "POST", `${base}/v1/artifact-sets`, options.uploadKey, { json: manifest });
+  const states = Array.isArray(created.files) ? created.files : [];
+  const done = /* @__PURE__ */ new Set();
+  let uploaded = 0;
+  for (const f of states) {
+    if (!f.sha256 || f.state === "uploaded" || done.has(f.sha256)) continue;
+    done.add(f.sha256);
+    const local = found.find((x) => x.file.sha256 === f.sha256);
+    if (!local) throw new Error(`Argus: server asks for unknown blob ${f.sha256}`);
+    log(`[argus] uploading ${local.file.name} (${local.file.size} bytes)`);
+    await call(doFetch, "PUT", `${base}/v1/artifact-sets/${id}/files/${f.sha256}`, options.uploadKey, { bytes: (0, import_node_fs3.readFileSync)(local.path) });
+    uploaded++;
+  }
+  const final = await call(doFetch, "POST", `${base}/v1/artifact-sets/${id}/finalize`, options.uploadKey);
+  const status = typeof final.status === "string" ? final.status : "unknown";
+  const queued = typeof final.reprocess_queued === "number" ? final.reprocess_queued : 0;
+  log(`[argus] set ${plan.artifactSetId}: ${status}, ${found.length} file(s), ${uploaded} uploaded${queued > 0 ? `, ${queued} waiting event(s) queued for reprocessing` : ""}`);
+  if (status !== "ready") throw new Error(`Argus: artifact set ${plan.artifactSetId} is not ready (${status})`);
+  return { status, uploaded, files: found.length };
+}
+
+// src/upload.ts
+function defaultExec(bin, args, opts) {
+  return new Promise((resolvePromise, reject) => {
+    const child = (0, import_node_child_process.spawn)(bin, args, { stdio: "inherit", env: opts.env, cwd: opts.cwd });
+    child.on("error", (e) => {
+      reject(e.code === "ENOENT" ? new Error(`Argus: cannot run "${bin}" \u2014 install the argus CLI or set ARGUS_BIN`) : e);
+    });
+    child.on("close", (code) => resolvePromise(code ?? 1));
+  });
+}
+async function runUploads(plans, options = {}) {
+  const env = options.env ?? process.env;
+  const cwd = options.cwd ?? process.cwd();
+  const bin = options.bin ?? env.ARGUS_BIN ?? "argus";
+  const exec = options.exec ?? defaultExec;
+  const log = options.log ?? ((line) => console.error(line));
+  const requested = options.transport ?? env.ARGUS_UPLOAD_TRANSPORT ?? "auto";
+  if (requested !== "auto" && requested !== "http" && requested !== "cli") throw new Error(`Argus: unknown upload transport "${requested}" (auto, http or cli)`);
+  const transport = requested;
+  const results = [];
+  if (!options.dryRun && !env.ARGUS_UPLOAD_KEY) throw new Error("Argus: ARGUS_UPLOAD_KEY is not set (an upload key, never the public ingest key)");
+  for (const plan of plans) {
+    const argOpts = {};
+    if (options.dryRun) argOpts.dryRun = true;
+    if (options.url) argOpts.url = options.url;
+    const args = uploadArgs(plan, argOpts);
+    const command = formatCommand(bin, args, cwd);
+    for (const w of plan.warnings) log(`[argus] warning: ${w}`);
+    log(`[argus] ${plan.label}: ${plan.files.length} file(s) \u2192 set ${plan.artifactSetId}`);
+    const viaHttp = transport === "http" || transport === "auto" && !options.exec && !env.ARGUS_BIN && isJsOnlyPlan(plan);
+    if (viaHttp) {
+      const url = options.url ?? env.ARGUS_URL;
+      if (!url) throw new Error("Argus: ARGUS_URL is not set (the server base URL, e.g. https://argus.example.com)");
+      const http = { url, uploadKey: env.ARGUS_UPLOAD_KEY ?? "", log };
+      if (options.dryRun) http.dryRun = true;
+      if (options.fetch) http.fetch = options.fetch;
+      let code2 = 0;
+      try {
+        await uploadPlanOverHttp(plan, http);
+      } catch (e) {
+        log(`[argus] ${e instanceof Error ? e.message : String(e)}`);
+        code2 = 1;
+      }
+      results.push({ plan, command: `http upload \u2192 ${url}`, code: code2 });
+      if (code2 !== 0) break;
+      continue;
+    }
+    const renamedMaps = Object.keys(plan.generatedFor ?? {}).length;
+    if (renamedMaps > 0) log(`[argus] warning: ${plan.label}: ${renamedMaps} source map(s) are tied to their chunk only by its sourceMappingURL comment (Turbopack); the argus CLI names them after the map file, so their frames will not resolve \u2014 use the http transport`);
+    const code = await exec(bin, args, { env, cwd });
+    results.push({ plan, command, code });
+    if (code !== 0) break;
+  }
+  return results;
+}
+
+// src/next-upload.ts
+async function uploadNextBuild(options) {
+  const env = options.env ?? process.env;
+  const log = options.log ?? ((line) => console.log(line));
+  const uploaded = [];
+  let error;
+  try {
+    const missing = ["ARGUS_URL", "ARGUS_UPLOAD_KEY"].filter((k) => !env[k]);
+    if (missing.length > 0) throw new Error(`${missing.join(" and ")} not set`);
+    if (!options.artifactSetId) throw new Error("no artifact set id (set ARGUS_ARTIFACT_SET_ID or the artifactSetId option)");
+    const plan = { projectDir: options.projectDir, distDir: options.distDir, artifactSetId: options.artifactSetId };
+    if (options.serverArtifactSetId) plan.serverArtifactSetId = options.serverArtifactSetId;
+    if (options.urlPrefix !== void 0) plan.urlPrefix = options.urlPrefix;
+    if (env.ARGUS_RELEASE) plan.release = env.ARGUS_RELEASE;
+    if (env.ARGUS_GIT_SHA) plan.gitSha = env.ARGUS_GIT_SHA;
+    const run = {
+      env,
+      cwd: options.projectDir,
+      // One line per chunk would bury the build log, and every Next build has runtime files
+      // without a map; the per-set summary line stays.
+      log: (line) => {
+        if (!line.startsWith("[argus] uploading ") && !line.endsWith("without a source map were skipped")) log(line);
+      }
+    };
+    if (options.fetch) run.fetch = options.fetch;
+    const results = await runUploads(planNext(plan), run);
+    for (const r of results) if (r.code === 0) uploaded.push(r.plan.artifactSetId);
+    const failed = results.find((r) => r.code !== 0);
+    if (failed) throw new Error(`${failed.plan.label} was not uploaded (${failed.command})`);
+  } catch (e) {
+    error = (e instanceof Error ? e.message : String(e)).replace(/^Argus: /, "");
+    if (options.onUploadError === "fail") {
+      throw new Error(`Argus: source map upload failed: ${error}`);
+    }
+    log(`[argus] warning: source map upload failed, the build continues (onUploadError: 'fail' stops it): ${error}`);
+  }
+  let deletedMaps = 0;
+  if (options.deleteBrowserMaps) {
+    const maps = browserSourceMaps(options.projectDir, options.distDir);
+    for (const m of maps) (0, import_node_fs4.rmSync)(m, { force: true });
+    deletedMaps = maps.length;
+    if (deletedMaps > 0) log(`[argus] removed ${deletedMaps} browser source map(s) from the build output${error ? " (they were not uploaded: errors of this build stay unsymbolicated)" : ""}`);
+  }
+  const result = { ok: !error, uploaded, deletedMaps };
+  if (error) result.error = error;
+  return result;
+}
+
+// src/next.ts
+function nextArtifactSetIds(options = {}) {
+  const env = options.env ?? process.env;
+  const web = resolveArtifactSetId(options.artifactSetId, "web", env);
+  const nodeExplicit = env.ARGUS_ARTIFACT_SET_ID_NODE || options.serverArtifactSetId;
+  const node = nodeExplicit ? assertArtifactSetId(nodeExplicit, "server artifact set id") : web ? assertArtifactSetId(`${web}-node`, "server artifact set id") : void 0;
+  return { web, node };
+}
+var PHASE_PRODUCTION_BUILD = "phase-production-build";
+var WARNED_ENV = "__ARGUS_NEXT_UPLOAD_WARNED";
+function installedNextVersion() {
+  try {
+    const { version } = (0, import_node_module2.createRequire)((0, import_node_path5.join)(process.cwd(), "package.json"))("next/package.json");
+    const m = /^(\d+)\.(\d+)\./.exec(version ?? "");
+    return m ? [Number(m[1]), Number(m[2])] : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function nextUrlPrefix(config) {
+  let base = typeof config.assetPrefix === "string" && config.assetPrefix ? config.assetPrefix : typeof config.basePath === "string" ? config.basePath : "";
+  if (/^https?:\/\//i.test(base)) {
+    try {
+      base = new URL(base).pathname;
+    } catch {
+      base = "";
+    }
+  }
+  const path = base.replace(/^\/+|\/+$/g, "");
+  return path ? `/${path}/_next/` : "/_next/";
+}
+function apply(config, options, phase) {
+  const env = options.env ?? process.env;
+  const mode = options.upload ?? "auto";
+  let uploads = mode === true || mode === "auto" && !!env.ARGUS_UPLOAD_KEY && !!env.ARGUS_URL;
+  if (uploads) {
+    const version = installedNextVersion();
+    if (version && (version[0] < 15 || version[0] === 15 && version[1] < 4)) {
+      uploads = false;
+      if (!env[WARNED_ENV]) {
+        env[WARNED_ENV] = "1";
+        (options.log ?? console.warn)(
+          `[argus] source maps are not uploaded by this build: Next ${version.join(".")} has no compiler.runAfterProductionCompile (15.4+). Run \`argus-build upload next --delete-maps\` after \`next build\`.`
+        );
+      }
+    }
+  }
+  let ids = nextArtifactSetIds(options);
+  const building = phase !== void 0 ? phase === PHASE_PRODUCTION_BUILD : env.NODE_ENV === "production";
+  if (uploads && building && !ids.web) {
+    env.ARGUS_ARTIFACT_SET_ID_WEB = newArtifactSetId("next");
+    ids = nextArtifactSetIds(options);
+  }
+  const out = { ...config, env: { ...config.env } };
+  if (ids.web) out.env[NEXT_PUBLIC_ENV] = ids.web;
+  if (ids.node) out.env[NEXT_SERVER_ENV] = ids.node;
+  const wantMaps = options.browserSourceMaps ?? uploads;
+  const enabledMaps = wantMaps && config.productionBrowserSourceMaps === void 0;
+  if (enabledMaps) out.productionBrowserSourceMaps = true;
+  if (options.serverSourceMaps ?? uploads) {
+    const previous = config.webpack;
+    out.webpack = (webpackConfig, context) => {
+      const next = typeof previous === "function" ? previous(webpackConfig, context) : webpackConfig;
+      if (context?.isServer && !context.dev) next.devtool = "source-map";
+      return next;
+    };
+  }
+  if (uploads) {
+    const compiler = config.compiler ?? {};
+    const previous = compiler.runAfterProductionCompile;
+    const hook = async (metadata) => {
+      if (typeof previous === "function") await previous(metadata);
+      const upload = {
+        projectDir: metadata.projectDir,
+        distDir: metadata.distDir,
+        artifactSetId: ids.web,
+        serverArtifactSetId: ids.node,
+        urlPrefix: options.urlPrefix ?? nextUrlPrefix(config),
+        onUploadError: options.onUploadError ?? "warn",
+        deleteBrowserMaps: options.deleteBrowserMapsAfterUpload ?? enabledMaps,
+        env
+      };
+      if (options.log) upload.log = options.log;
+      await uploadNextBuild(upload);
+    };
+    out.compiler = { ...compiler, runAfterProductionCompile: hook };
+  }
+  return out;
+}
+function withArgus2(nextConfig, options = {}) {
+  if (typeof nextConfig === "function") {
+    return (phase, context) => {
+      const result = nextConfig(phase, context);
+      return result instanceof Promise ? result.then((c) => apply(c, options, phase)) : apply(result, options, phase);
+    };
+  }
+  return apply(nextConfig, options, void 0);
+}
+
+// src/cli.ts
+var import_node_fs6 = require("fs");
+var import_node_path7 = require("path");
+var import_node_readline = require("readline");
+
+// src/init.ts
+var import_node_child_process2 = require("child_process");
+var import_node_fs5 = require("fs");
+var import_node_path6 = require("path");
+var isDir = (p) => (0, import_node_fs5.existsSync)(p) && (0, import_node_fs5.statSync)(p).isDirectory();
+var LOCKFILES = [
+  ["pnpm-lock.yaml", "pnpm"],
+  ["yarn.lock", "yarn"],
+  ["bun.lockb", "bun"],
+  ["bun.lock", "bun"],
+  ["package-lock.json", "npm"]
+];
+function detectPackageManager(dir, pkg = {}) {
+  const declared = typeof pkg.packageManager === "string" ? /^(pnpm|yarn|npm|bun)@/.exec(pkg.packageManager)?.[1] : void 0;
+  if (declared) return declared;
+  for (let d = (0, import_node_path6.resolve)(dir); ; d = (0, import_node_path6.dirname)(d)) {
+    for (const [file, pm] of LOCKFILES) if ((0, import_node_fs5.existsSync)((0, import_node_path6.join)(d, file))) return pm;
+    if ((0, import_node_path6.dirname)(d) === d) return "npm";
+  }
+}
+function versionOf(dir, declared) {
+  let version;
+  try {
+    version = JSON.parse((0, import_node_fs5.readFileSync)((0, import_node_path6.join)(dir, "node_modules/next/package.json"), "utf8")).version;
+  } catch {
+    version = declared;
+  }
+  const m = /(\d+)(?:\.(\d+))?/.exec(version ?? "");
+  return m ? [Number(m[1]), Number(m[2] ?? 0)] : void 0;
+}
+function detectProject(dir) {
+  const root = (0, import_node_path6.resolve)(dir);
+  const pkgPath = (0, import_node_path6.join)(root, "package.json");
+  if (!(0, import_node_fs5.existsSync)(pkgPath)) throw new Error(`no package.json in ${root} \u2014 run this in the directory of the app (in a monorepo: the app's own package)`);
+  let pkg;
+  try {
+    pkg = JSON.parse((0, import_node_fs5.readFileSync)(pkgPath, "utf8"));
+  } catch (e) {
+    throw new Error(`cannot read ${pkgPath}: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  const deps = /* @__PURE__ */ new Set([...Object.keys(pkg.dependencies ?? {}), ...Object.keys(pkg.devDependencies ?? {})]);
+  const info = {
+    kind: deps.has("next") ? "next" : deps.has("expo") ? "expo" : deps.has("react-native") ? "react-native" : "node",
+    dir: root,
+    name: typeof pkg.name === "string" ? pkg.name : void 0,
+    typescript: (0, import_node_fs5.existsSync)((0, import_node_path6.join)(root, "tsconfig.json")) || deps.has("typescript"),
+    esm: pkg.type === "module",
+    packageManager: detectPackageManager(root, pkg),
+    deps,
+    sourceDir: ""
+  };
+  if (info.kind === "next") {
+    const rootRouter = isDir((0, import_node_path6.join)(root, "app")) || isDir((0, import_node_path6.join)(root, "pages"));
+    const src = !rootRouter && (isDir((0, import_node_path6.join)(root, "src/app")) || isDir((0, import_node_path6.join)(root, "src/pages")));
+    info.sourceDir = src ? "src" : "";
+    info.router = isDir((0, import_node_path6.join)(root, info.sourceDir, "app")) ? "app" : isDir((0, import_node_path6.join)(root, info.sourceDir, "pages")) ? "pages" : "app";
+    info.nextConfig = ["next.config.ts", "next.config.mjs", "next.config.js", "next.config.cjs"].find((f) => (0, import_node_fs5.existsSync)((0, import_node_path6.join)(root, f)));
+    info.nextVersion = versionOf(root, pkg.dependencies?.next ?? pkg.devDependencies?.next);
+  } else if (info.kind === "node") {
+    info.sourceDir = isDir((0, import_node_path6.join)(root, "src")) ? "src" : "";
+    info.main = typeof pkg.main === "string" ? pkg.main : void 0;
+  }
+  return info;
+}
+function nextInstrumentation(typescript) {
+  const args = typescript ? "...args: unknown[]" : "...args";
+  const call2 = typescript ? "(onRequestError as (...a: unknown[]) => Promise<void>)(...args)" : "onRequestError(...args)";
+  return `// Argus server-side capture. Next calls register() once per server process.
+export async function register() {
+  if (process.env.NEXT_RUNTIME === 'nodejs') {
+    const { register } = await import('@getargus/node/next');
+    // DSN, environment and release are read from ARGUS_DSN / ARGUS_ENVIRONMENT / ARGUS_RELEASE.
+    register({ artifactSetId: process.env.ARGUS_SERVER_ARTIFACT_SET_ID });
+  }
+}
+
+// Errors of server components, route handlers and server actions.
+export const onRequestError = async (${args}) => {
+  if (process.env.NEXT_RUNTIME === 'nodejs') {
+    const { onRequestError } = await import('@getargus/node/next');
+    return ${call2};
+  }
+};
+`;
+}
+function nextInstrumentationClient() {
+  return `// Argus browser capture; Next loads this file before the app hydrates.
+import { initClient } from '@getargus/browser/next';
+
+// The DSN is read from NEXT_PUBLIC_ARGUS_DSN (inlined at build time).
+initClient({ artifactSetId: process.env.NEXT_PUBLIC_ARGUS_ARTIFACT_SET_ID });
+
+export { onRouterTransitionStart } from '@getargus/browser/next';
+`;
+}
+function nodeSetup(style) {
+  const load = style === "esm" ? "import { init } from '@getargus/node';" : "const { init } = require('@getargus/node');";
+  return `// Argus: load this file first in the entry file, so capture is installed before anything else runs.
+${load}
+
+init(); // reads ARGUS_DSN, ARGUS_ENVIRONMENT (else NODE_ENV) and ARGUS_RELEASE
+`;
+}
+var WITH_ARGUS_IMPORT = "import { withArgus } from '@getargus/build-tools/next';";
+var WITH_ARGUS_REQUIRE = "const { withArgus } = require('@getargus/build-tools/next');";
+function wrapNextConfig(source) {
+  const esm = [...source.matchAll(/^export default ([A-Za-z_$][\w$]*);?[ \t]*$/gm)];
+  const cjs = [...source.matchAll(/^module\.exports = ([A-Za-z_$][\w$]*);?[ \t]*$/gm)];
+  if (esm.length + cjs.length !== 1) return void 0;
+  const isEsm = esm.length === 1;
+  if (isEsm ? /\bmodule\.exports\b/.test(source) : /^export /m.test(source)) return void 0;
+  const m = (isEsm ? esm : cjs)[0];
+  const wrapped = isEsm ? `export default withArgus(${m[1]});` : `module.exports = withArgus(${m[1]});`;
+  const header = isEsm ? WITH_ARGUS_IMPORT : WITH_ARGUS_REQUIRE;
+  const body = source.slice(0, m.index) + wrapped + source.slice(m.index + m[0].length);
+  return { content: `${header}
+${body}`, removed: m[0], added: [header, wrapped] };
+}
+var DSN_FORM = "https://<ingest key>@<host>";
+var RE_DSN = /^https?:\/\/[^@\s/]+@[^@\s/]+/;
+function read(dir, file) {
+  try {
+    return (0, import_node_fs5.readFileSync)((0, import_node_path6.join)(dir, file), "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function installCommand(pm, packages) {
+  return `${pm === "npm" ? "npm install" : `${pm} add`} ${packages.join(" ")}`;
+}
+function envBlock(existing, entries) {
+  const has = (key) => new RegExp(`^\\s*(?:export\\s+)?${key}\\s*=`, "m").test(existing ?? "");
+  const lines = [];
+  const keys = [];
+  for (const [key, value, comment] of entries) {
+    if (has(key)) continue;
+    if (comment) lines.push(`# ${comment}`);
+    lines.push(`${key}=${value}`);
+    keys.push(key);
+  }
+  if (keys.length === 0) return { text: "", keys };
+  const lead = existing === void 0 || existing === "" ? "" : existing.endsWith("\n") ? "\n" : "\n\n";
+  return { text: `${lead}${lines.join("\n")}
+`, keys };
+}
+function envAction(dir, file, entries, why) {
+  const existing = read(dir, file);
+  const block = envBlock(existing, entries);
+  if (block.keys.length === 0) return { type: "ok", file, summary: "already lists the Argus variables" };
+  return {
+    type: existing === void 0 ? "create" : "append",
+    file,
+    summary: `${block.keys.join(", ")} \u2014 ${why}`,
+    content: block.text,
+    preview: block.text.trim()
+  };
+}
+function isGitIgnored(dir, file) {
+  const git = (0, import_node_child_process2.spawnSync)("git", ["check-ignore", "-q", file], { cwd: dir, stdio: "ignore" });
+  if (git.status === 0) return true;
+  if (git.status === 1) return false;
+  let ignored = false;
+  for (const raw of (read(dir, ".gitignore") ?? "").split("\n")) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    const negated = line.startsWith("!");
+    const pattern = line.replace(/^!/, "").replace(/^\//, "");
+    if (pattern.includes("/")) continue;
+    const escaped = pattern.replace(/[.+^$(){}|[\]\\]/g, "\\$&");
+    const re = new RegExp(`^${escaped.replace(/\*/g, ".*").replace(/\?/g, ".")}$`);
+    if (re.test(file)) ignored = !negated;
+  }
+  return ignored;
+}
+function dsnAction(dir, file, entries) {
+  const existing = read(dir, file);
+  const block = envBlock(existing, entries);
+  if (block.keys.length === 0) return { type: "ok", file, summary: `already sets ${entries.map(([k]) => k).join(", ")}` };
+  if (!isGitIgnored(dir, file)) {
+    return {
+      type: "manual",
+      file,
+      summary: `not git-ignored, so the DSN was not written \u2014 add "${file}" to .gitignore, then put this in it`,
+      preview: block.text.trim()
+    };
+  }
+  return { type: existing === void 0 ? "create" : "append", file, summary: `${block.keys.join(", ")} (git-ignored)`, content: block.text, preview: block.text.trim() };
+}
+var USES_ARGUS = /@getargus\//;
+function sourceFile(dir, candidates, create, content, summary) {
+  const existing = candidates.find((f) => (0, import_node_fs5.existsSync)((0, import_node_path6.join)(dir, f)));
+  if (!existing) return { type: "create", file: create, summary, content, preview: content.trimEnd() };
+  if (USES_ARGUS.test(read(dir, existing) ?? "")) return { type: "ok", file: existing, summary: "already uses Argus" };
+  return { type: "manual", file: existing, summary: "exists and is not overwritten \u2014 merge this into it", preview: content.trimEnd() };
+}
+function planNextProject(p, dsn) {
+  const ext = p.typescript ? "ts" : "js";
+  const at = (name) => p.sourceDir ? `${p.sourceDir}/${name}` : name;
+  const variants = (base) => ["ts", "tsx", "js", "jsx", "mjs"].flatMap((e) => [`${base}.${e}`, `src/${base}.${e}`]);
+  const actions = [
+    sourceFile(p.dir, variants("instrumentation"), at(`instrumentation.${ext}`), nextInstrumentation(p.typescript), "server capture: register() + onRequestError"),
+    sourceFile(p.dir, variants("instrumentation-client"), at(`instrumentation-client.${ext}`), nextInstrumentationClient(), "browser capture: initClient()")
+  ];
+  if (!p.nextConfig) {
+    const content = `${WITH_ARGUS_IMPORT}
+
+export default withArgus({});
+`;
+    actions.push({ type: "create", file: "next.config.mjs", summary: "build id + source map upload: withArgus()", content, preview: content.trimEnd() });
+  } else {
+    const source = read(p.dir, p.nextConfig) ?? "";
+    const wrapped = /\bwithArgus\b/.test(source) ? void 0 : wrapNextConfig(source);
+    if (/\bwithArgus\b/.test(source)) actions.push({ type: "ok", file: p.nextConfig, summary: "already wrapped with withArgus" });
+    else if (wrapped) {
+      actions.push({
+        type: "modify",
+        file: p.nextConfig,
+        summary: "wrap the exported config with withArgus()",
+        content: wrapped.content,
+        preview: [`- ${wrapped.removed}`, ...wrapped.added.map((l) => `+ ${l}`)].join("\n")
+      });
+    } else {
+      const cjs = /\bmodule\.exports\b/.test(source);
+      actions.push({
+        type: "manual",
+        file: p.nextConfig,
+        summary: "its export is not a plain identifier, so it was left alone \u2014 wrap it yourself",
+        preview: cjs ? `+ ${WITH_ARGUS_REQUIRE}
+- module.exports = <your config>;
++ module.exports = withArgus(<your config>);` : `+ ${WITH_ARGUS_IMPORT}
+- export default <your config>;
++ export default withArgus(<your config>);`
+      });
+    }
+  }
+  actions.push(
+    envAction(
+      p.dir,
+      ".env.example",
+      [
+        ["ARGUS_DSN", "", `Argus (${DSN_FORM}). The browser needs the same value under the NEXT_PUBLIC_ name.`],
+        ["NEXT_PUBLIC_ARGUS_DSN", ""],
+        ["ARGUS_URL", "", "Build / CI only: with both set, `next build` uploads source maps. An upload key, never the ingest key."],
+        ["ARGUS_UPLOAD_KEY", ""]
+      ],
+      "names only, no values"
+    )
+  );
+  if (dsn) actions.push(dsnAction(p.dir, ".env.local", [["ARGUS_DSN", dsn], ["NEXT_PUBLIC_ARGUS_DSN", dsn]]));
+  const missing = ["@getargus/node", "@getargus/browser", "@getargus/build-tools"].filter((d) => !p.deps.has(d));
+  const nextSteps = [];
+  if (!dsn) nextSteps.push(`Set ARGUS_DSN and NEXT_PUBLIC_ARGUS_DSN (${DSN_FORM}) in .env.local and in your deployment.`);
+  else nextSteps.push("Set ARGUS_DSN and NEXT_PUBLIC_ARGUS_DSN in your deployment too (.env.local is for this machine).");
+  nextSteps.push("Set ARGUS_URL and ARGUS_UPLOAD_KEY where `next build` runs (CI): source maps are then uploaded at the end of the build.");
+  const v = p.nextVersion;
+  if (v && (v[0] < 15 || v[0] === 15 && v[1] < 3)) nextSteps.push(`Next ${v.join(".")} does not load instrumentation-client (15.3+): import that file from your earliest client entry instead.`);
+  if (v && (v[0] < 15 || v[0] === 15 && v[1] < 4)) nextSteps.push(`Next ${v.join(".")} has no post-compile hook (15.4+): run \`argus-build upload next --delete-maps\` after \`next build\`.`);
+  if (p.router === "app") nextSteps.push("Optional: report render errors from app/error.tsx and app/global-error.tsx with captureNextError (see '@getargus/browser/next').");
+  return { project: p, actions, install: missing.length > 0 ? installCommand(p.packageManager, missing) : void 0, nextSteps };
+}
+function planNodeProject(p, dsn) {
+  const mainExt = (0, import_node_path6.extname)(p.main ?? "");
+  const ext = p.typescript ? ".ts" : mainExt === ".mjs" || mainExt === ".cjs" ? mainExt : ".js";
+  const style = ext === ".mjs" ? "esm" : ext === ".cjs" ? "cjs" : p.typescript || p.esm ? "esm" : "cjs";
+  const at = (name) => p.sourceDir ? `${p.sourceDir}/${name}` : name;
+  const variants = [".ts", ".js", ".mjs", ".cjs"].flatMap((e) => [`argus${e}`, `src/argus${e}`]);
+  const setup = sourceFile(p.dir, variants, at(`argus${ext}`), nodeSetup(style), "init() from the environment");
+  const actions = [
+    setup,
+    envAction(p.dir, ".env.example", [["ARGUS_DSN", "", `Argus (${DSN_FORM})`], ["ARGUS_RELEASE", "", "Optional: what the dashboard shows as the version, e.g. api@1.2.0"]], "names only, no values")
+  ];
+  if (dsn) actions.push(dsnAction(p.dir, ".env", [["ARGUS_DSN", dsn]]));
+  const nodeNext = /"module(?:Resolution)?"\s*:\s*"node(?:16|next)"/i.test(read(p.dir, "tsconfig.json") ?? "");
+  const base = setup.file.replace(/^src\//, "");
+  const specifier = p.typescript ? nodeNext ? "./argus.js" : "./argus" : `./${base}`;
+  const line = style === "esm" ? `import '${specifier}';` : `require('${specifier}');`;
+  const entry = p.main ?? (p.sourceDir ? `${p.sourceDir}/index${ext}` : `index${ext}`);
+  const nextSteps = [
+    `Make this the first line of your entry file (${entry}; adjust the path if the entry is in another directory):
+
+      ${line}
+`,
+    dsn ? "Node does not read .env by itself: start with `node --env-file=.env \u2026` or export ARGUS_DSN in the process environment." : `Set ARGUS_DSN (${DSN_FORM}) in the process environment. Without it the SDK is disabled and every call is a no-op.`
+  ];
+  const missing = ["@getargus/node"].filter((d) => !p.deps.has(d));
+  return { project: p, actions, install: missing.length > 0 ? installCommand(p.packageManager, missing) : void 0, nextSteps };
+}
+function planMobileProject(p) {
+  const expo = p.kind === "expo";
+  const wanted = expo ? ["@getargus/react-native", "@getargus/expo", "@getargus/build-tools", "expo-sqlite"] : ["@getargus/react-native", "@getargus/build-tools"];
+  const missing = wanted.filter((d) => !p.deps.has(d));
+  const metro = expo ? "const { getDefaultConfig } = require('expo/metro-config');\n      const { withArgus } = require('@getargus/build-tools/metro');\n      module.exports = withArgus(getDefaultConfig(__dirname));" : "const { withArgus } = require('@getargus/build-tools/metro');\n      module.exports = withArgus(<your metro config>);";
+  const nextSteps = [
+    ...expo ? [`app.json \u2014 add the config plugin (native crash capture; needs a development or release build, not Expo Go):
+
+      "plugins": [["@getargus/expo", { "release": "${p.name ?? "app"}@1.0.0" }]]
+`] : ["Native crash capture needs @getargus/expo, an Expo module: add it once the project has expo-modules-core; JS errors work without it."],
+    `metro.config.js \u2014 compile the build's artifact set id into the bundle:
+
+      ${metro}
+`,
+    `Entry file (before anything else of the app is imported):
+
+      import { init } from '@getargus/react-native';
+      init({ dsn: '${DSN_FORM}', release: '${p.name ?? "app"}@1.0.0' });
+`,
+    "Add `.argus/` to .gitignore (generated by the Metro helper).",
+    'After `expo export` / an EAS build, upload the source maps (ARGUS_URL and ARGUS_UPLOAD_KEY in the environment):\n\n      npx argus-build upload expo-export --ios-set-id "$ARGUS_ARTIFACT_SET_ID_IOS" --android-set-id "$ARGUS_ARTIFACT_SET_ID_ANDROID"\n'
+  ];
+  return { project: p, actions: [], install: missing.length > 0 ? installCommand(p.packageManager, missing) : void 0, nextSteps };
+}
+function planInit(options = {}) {
+  if (options.dsn !== void 0 && !RE_DSN.test(options.dsn)) throw new Error(`--dsn must look like ${DSN_FORM}`);
+  const project = detectProject(options.dir ?? process.cwd());
+  if (project.kind === "next") return planNextProject(project, options.dsn);
+  if (project.kind === "node") return planNodeProject(project, options.dsn);
+  return planMobileProject(project);
+}
+function applyInit(plan) {
+  const written = [];
+  for (const a of plan.actions) {
+    if (a.content === void 0 || a.type === "ok" || a.type === "manual") continue;
+    const path = (0, import_node_path6.join)(plan.project.dir, a.file);
+    if (a.type === "create") {
+      (0, import_node_fs5.mkdirSync)((0, import_node_path6.dirname)(path), { recursive: true });
+      (0, import_node_fs5.writeFileSync)(path, a.content, { flag: "wx" });
+    } else if (a.type === "append") (0, import_node_fs5.writeFileSync)(path, a.content, { flag: "a" });
+    else (0, import_node_fs5.writeFileSync)(path, a.content);
+    written.push(a.file);
+  }
+  return written;
+}
+var KIND_LABEL = { next: "Next.js", expo: "Expo", "react-native": "React Native", node: "Node.js" };
+function describeProject(p) {
+  const parts = [];
+  if (p.kind === "next") parts.push(`${p.router} router`, p.sourceDir ? "src/" : "no src/");
+  if (p.kind === "node") parts.push(p.typescript || p.esm ? "ESM" : "CommonJS");
+  if (p.kind === "next" || p.kind === "node") parts.push(p.typescript ? "TypeScript" : "JavaScript");
+  parts.push(p.packageManager);
+  return `${KIND_LABEL[p.kind]} (${parts.join(", ")})`;
+}
+var indent = (text) => text.split("\n").map((l) => l ? `      ${l}` : "").join("\n");
+var isWrite = (a) => a.type === "create" || a.type === "append" || a.type === "modify";
+function renderActions(plan, mode) {
+  const out = [`Argus init \u2014 ${describeProject(plan.project)} in ${plan.project.dir}`, ""];
+  const done = mode === "applied";
+  const verb = {
+    create: done ? "created " : "create  ",
+    append: done ? "appended" : "append  ",
+    modify: done ? "modified" : "modify  ",
+    ok: "ok      ",
+    manual: "manual  "
+  };
+  for (const a of plan.actions) {
+    out.push(`  ${verb[a.type]}  ${a.file} \u2014 ${a.summary}`);
+    if (a.preview) out.push("", indent(a.preview), "");
+  }
+  return out.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd();
+}
+function renderOutcome(plan, mode) {
+  const out = [];
+  const writes = plan.actions.filter(isWrite).length;
+  if (plan.actions.length > 0) {
+    if (writes === 0) out.push("Nothing to write.");
+    else if (mode === "applied") out.push(`${writes} file(s) written.`);
+    else if (mode === "dry-run") out.push(`Dry run: ${writes} file(s) would be written, nothing was changed.`);
+    else out.push(`Nothing was changed: ${writes} file(s) would be written. Run again with --yes to write them.`);
+    out.push("");
+  }
+  if (plan.install) out.push("Install the packages:", "", `      ${plan.install}`, "");
+  if (plan.nextSteps.length > 0) {
+    out.push(plan.actions.length > 0 ? "Then:" : "Steps (nothing is edited automatically for a native app):", "");
+    plan.nextSteps.forEach((s2, n) => out.push(`  ${n + 1}. ${s2}`));
+  }
+  return out.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd();
+}
+function renderInit(plan, mode) {
+  return `${renderActions(plan, mode)}
+
+${renderOutcome(plan, mode)}`;
+}
+async function runInit(options = {}) {
+  const out = options.out ?? ((t) => void process.stdout.write(`${t}
+`));
+  const plan = planInit(options);
+  let apply2 = !!options.yes && !options.dryRun;
+  if (!apply2 && !options.dryRun && options.confirm && plan.actions.some(isWrite)) {
+    out(renderActions(plan, "preview"));
+    apply2 = await options.confirm("\nWrite these files? [y/N] ");
+    const written2 = apply2 ? applyInit(plan) : [];
+    out(`
+${renderOutcome(plan, apply2 ? "applied" : "preview")}`);
+    return { plan, written: written2 };
+  }
+  const written = apply2 ? applyInit(plan) : [];
+  out(renderInit(plan, apply2 ? "applied" : options.dryRun ? "dry-run" : "preview"));
+  return { plan, written };
+}
+
+// src/cli.ts
+var USAGE = `argus-build <command>
+
+  init [--dsn <dsn>] [--yes] [--dry-run] [--dir <project>]
+                                            set a Next.js / Node / Expo project up for Argus: prints every file it
+                                            would write; writes with --yes (or after asking, on a terminal); never
+                                            overwrites a file, never installs anything
+  new-id [--prefix <p>]                     print a new artifact set id (same format as \`argus artifacts new-id\`)
+  prelude --set-id <id> --out <file>        write the generated module that defines globalThis.__ARGUS_ARTIFACT_SET_ID__
+  collect <target> [options]                print what would be uploaded, per artifact set (no network)
+  upload  <target> [options]                upload each artifact set (JS sets over HTTP, native symbols via the argus CLI)
+
+Targets
+  next          --set-id <web id> [--server-set-id <id>] [--dir <project>] [--dist-dir .next] [--url-prefix /_next/]
+                browser chunks and server chunks go to two different sets (default server id: <web id>-node)
+  expo-export   --ios-set-id <id> --android-set-id <id> [--dir dist] [--platform ios|android]
+                [--update-id <id> | --ios-update-id <id> --android-update-id <id>]
+                [--parent-set-id <id> | --ios-parent-set-id <id> --android-parent-set-id <id>] [--runtime-version <v>]
+  ios           --set-id <id> --dir <xcarchive | dSYMs | build dir>... [--bundle <main.jsbundle>] [--sourcemap <map>]
+  android       --set-id <id> --dir <android/app/build>... [--bundle <f>] [--sourcemap <map>] [--native-libs]
+  files         --set-id <id> --platform <ios|android|web|node> --dir <dir or file>... [--strip-prefix <p>] [--url-prefix <p>]
+
+Common options
+  --release <r> --dist <d> --native-release <v> --native-build <b> --runtime-version <v> --git-sha <sha>
+  --no-bundles          upload source maps only (next, files)
+  --json                collect: machine readable output
+  --dry-run             upload: print the manifests and upload nothing
+  --print               upload: only print the commands
+  --transport <t>       upload: http (from Node, JS artifacts only), cli (the argus binary) or auto (default:
+                        http for JS-only sets, cli for native symbols)
+  --delete-maps         upload next: delete browser .map files from the build output after a successful upload
+  --argus-bin <path>    the argus binary (default $ARGUS_BIN, else "argus")
+  --url <base url>      server (default: $ARGUS_URL as read by the argus CLI)
+
+Environment: ARGUS_UPLOAD_KEY (upload key; never passed on the command line), ARGUS_URL, ARGUS_BIN, ARGUS_GIT_SHA.
+`;
+var BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["yes", "json", "dry-run", "print", "no-bundles", "delete-maps", "native-libs", "help"]);
+var MULTI_FLAGS = /* @__PURE__ */ new Set(["dir"]);
+function parseArgs(argv) {
+  const out = { positionals: [], flags: {}, multi: {} };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (!a.startsWith("--")) {
+      out.positionals.push(a);
+      continue;
+    }
+    const eq = a.indexOf("=");
+    const name = a.slice(2, eq === -1 ? void 0 : eq);
+    if (BOOLEAN_FLAGS.has(name)) {
+      out.flags[name] = true;
+      continue;
+    }
+    const value = eq === -1 ? argv[++i] : a.slice(eq + 1);
+    if (value === void 0) throw new Error(`missing value for --${name}`);
+    if (MULTI_FLAGS.has(name)) (out.multi[name] ??= []).push(value);
+    else out.flags[name] = value;
+  }
+  return out;
+}
+var s = (v) => typeof v === "string" ? v : void 0;
+function need(args, name) {
+  const v = s(args.flags[name]);
+  if (!v) throw new Error(`--${name} is required`);
+  return v;
+}
+function metaOf(args, env) {
+  return {
+    release: s(args.flags.release),
+    dist: s(args.flags.dist),
+    nativeRelease: s(args.flags["native-release"]),
+    nativeBuild: s(args.flags["native-build"]),
+    runtimeVersion: s(args.flags["runtime-version"]),
+    gitSha: s(args.flags["git-sha"]) ?? env.ARGUS_GIT_SHA
+  };
+}
+function plansFor(target, args, env = process.env, cwd = process.cwd()) {
+  const meta2 = metaOf(args, env);
+  const dirs = (args.multi.dir ?? []).map((d) => (0, import_node_path7.resolve)(cwd, d));
+  const setId = () => s(args.flags["set-id"]) ?? env.ARGUS_ARTIFACT_SET_ID ?? need(args, "set-id");
+  switch (target) {
+    case "next": {
+      const opts = { ...meta2, projectDir: dirs[0] ?? cwd, artifactSetId: setId(), includeBundles: !args.flags["no-bundles"] };
+      const serverId = s(args.flags["server-set-id"]) ?? env.ARGUS_ARTIFACT_SET_ID_NODE;
+      if (serverId) opts.serverArtifactSetId = serverId;
+      const distDir = s(args.flags["dist-dir"]);
+      if (distDir) opts.distDir = distDir;
+      const urlPrefix = s(args.flags["url-prefix"]);
+      if (urlPrefix !== void 0) opts.urlPrefix = urlPrefix;
+      return planNext(opts);
+    }
+    case "expo-export": {
+      const per = (flag, envName) => {
+        const out = {};
+        for (const p of ["ios", "android"]) {
+          const v = s(args.flags[`${p}-${flag}`]) ?? (envName ? env[`${envName}_${p.toUpperCase()}`] : void 0);
+          if (v) out[p] = v;
+        }
+        return out;
+      };
+      const opts = { ...meta2, exportDir: dirs[0] ?? (0, import_node_path7.resolve)(cwd, "dist"), artifactSetIds: per("set-id", "ARGUS_ARTIFACT_SET_ID") };
+      const platform = s(args.flags.platform);
+      if (platform) {
+        if (platform !== "ios" && platform !== "android") throw new Error("--platform must be ios or android for expo-export");
+        opts.platforms = [platform];
+        const generic = s(args.flags["set-id"]) ?? env.ARGUS_ARTIFACT_SET_ID;
+        if (!opts.artifactSetIds[platform] && generic) opts.artifactSetIds[platform] = generic;
+      }
+      const updateIds = per("update-id");
+      const oneUpdate = s(args.flags["update-id"]);
+      if (Object.keys(updateIds).length > 0) opts.updateId = updateIds;
+      else if (oneUpdate) opts.updateId = oneUpdate;
+      const parents = per("parent-set-id");
+      const oneParent = s(args.flags["parent-set-id"]);
+      if (oneParent && platform) parents[platform] ??= oneParent;
+      else if (oneParent) throw new Error("--parent-set-id needs --platform; a native build set belongs to one platform (use --ios-parent-set-id / --android-parent-set-id)");
+      if (Object.keys(parents).length > 0) opts.parentSetIds = parents;
+      return planExpoExport(opts);
+    }
+    case "ios":
+    case "android": {
+      if (dirs.length === 0) throw new Error("--dir is required (where the build left its dSYMs / mapping.txt / bundle map)");
+      const opts = { ...meta2, platform: target, artifactSetId: setId(), searchPaths: dirs };
+      const bundle = s(args.flags.bundle);
+      const sourcemap = s(args.flags.sourcemap);
+      if (bundle) opts.bundle = (0, import_node_path7.resolve)(cwd, bundle);
+      if (sourcemap) opts.sourcemap = (0, import_node_path7.resolve)(cwd, sourcemap);
+      if (args.flags["native-libs"]) opts.includeNativeLibs = true;
+      return [planNative(opts)];
+    }
+    case "files": {
+      const platform = need(args, "platform");
+      if (!["ios", "android", "web", "node"].includes(platform)) throw new Error("--platform must be ios, android, web or node");
+      if (dirs.length === 0) throw new Error("--dir is required");
+      const opts = { ...meta2, artifactSetId: setId(), platform, paths: dirs, includeBundles: !args.flags["no-bundles"] };
+      const strip = s(args.flags["strip-prefix"]);
+      if (strip) opts.stripPrefix = (0, import_node_path7.resolve)(cwd, strip);
+      const urlPrefix = s(args.flags["url-prefix"]);
+      if (urlPrefix !== void 0) opts.urlPrefix = urlPrefix;
+      return [planFiles(opts)];
+    }
+    default:
+      throw new Error(`unknown target "${target}" (next, expo-export, ios, android, files)`);
+  }
+}
+function renderPlans(plans, bin, cwd) {
+  const lines = [];
+  const rel = (p) => p.startsWith(cwd + import_node_path7.sep) ? (0, import_node_path7.relative)(cwd, p) : p;
+  for (const plan of plans) {
+    lines.push(`${plan.label}  set=${plan.artifactSetId}  platform=${plan.platform}${plan.ota ? "  ota" : ""}${plan.updateId ? `  update=${plan.updateId}` : ""}${plan.parentSetId ? `  parent=${plan.parentSetId}` : ""}`);
+    for (const f of plan.files) {
+      const name = f.kind === "sourcemap" || f.kind === "js_bundle" ? `  \u2192 ${manifestName(plan, f.path)}` : "";
+      lines.push(`  ${f.kind.padEnd(9)} ${String(f.size).padStart(9)}  ${rel(f.path)}${name}`);
+    }
+    for (const w of plan.warnings) lines.push(`  warning: ${w}`);
+    lines.push(`  $ ${formatCommand(bin, uploadArgs(plan), cwd)}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function ttyConfirm(question) {
+  const rl = (0, import_node_readline.createInterface)({ input: process.stdin, output: process.stdout });
+  return new Promise((done) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      done(/^y(es)?$/i.test(answer.trim()));
+    });
+  });
+}
+async function main(argv, io = {}) {
+  const out = io.out ?? ((t) => void process.stdout.write(`${t}
+`));
+  const err = io.err ?? ((t) => void process.stderr.write(`${t}
+`));
+  const env = io.env ?? process.env;
+  const cwd = io.cwd ?? process.cwd();
+  try {
+    const args = parseArgs(argv);
+    const [command, target] = args.positionals;
+    if (!command || args.flags.help || command === "help") {
+      out(USAGE);
+      return command || args.flags.help ? 0 : 2;
+    }
+    const bin = s(args.flags["argus-bin"]) ?? env.ARGUS_BIN ?? "argus";
+    switch (command) {
+      case "init": {
+        const opts = { dir: (0, import_node_path7.resolve)(cwd, (args.multi.dir ?? [])[0] ?? "."), out };
+        const dsn = s(args.flags.dsn);
+        if (dsn) opts.dsn = dsn;
+        if (args.flags.yes) opts.yes = true;
+        if (args.flags["dry-run"]) opts.dryRun = true;
+        const confirm = io.confirm ?? (process.stdin.isTTY && process.stdout.isTTY && !io.out ? ttyConfirm : void 0);
+        if (confirm) opts.confirm = confirm;
+        await runInit(opts);
+        return 0;
+      }
+      case "new-id":
+        out(newArtifactSetId(s(args.flags.prefix) ?? "build"));
+        return 0;
+      case "prelude": {
+        const res = writeArtifactSetModule({ file: (0, import_node_path7.resolve)(cwd, need(args, "out")), artifactSetId: s(args.flags["set-id"]) ?? env.ARGUS_ARTIFACT_SET_ID ?? need(args, "set-id") });
+        out(res.file);
+        return 0;
+      }
+      case "collect": {
+        if (!target) throw new Error("collect needs a target (next, expo-export, ios, android, files)");
+        const plans = plansFor(target, args, env, cwd);
+        if (args.flags.json) out(JSON.stringify(plans.map((p) => ({ ...p, args: uploadArgs(p) })), null, 2));
+        else out(renderPlans(plans, bin, cwd));
+        return 0;
+      }
+      case "upload": {
+        if (!target) throw new Error("upload needs a target (next, expo-export, ios, android, files)");
+        const plans = plansFor(target, args, env, cwd);
+        if (args.flags.print) {
+          for (const p of plans) out(formatCommand(bin, uploadArgs(p, args.flags["dry-run"] ? { dryRun: true } : {}), cwd));
+          return 0;
+        }
+        const runOpts = { bin, env, cwd, log: err };
+        if (args.flags["dry-run"]) runOpts.dryRun = true;
+        const url = s(args.flags.url);
+        if (url) runOpts.url = url;
+        if (io.exec) runOpts.exec = io.exec;
+        const transport = s(args.flags.transport);
+        if (transport) runOpts.transport = transport;
+        else if (s(args.flags["argus-bin"])) runOpts.transport = "cli";
+        const results = await runUploads(plans, runOpts);
+        const failed = results.find((r) => r.code !== 0);
+        if (failed) {
+          err(`[argus] upload failed for ${failed.plan.label} (exit ${failed.code}): ${failed.command}`);
+          return failed.code || 1;
+        }
+        if (target === "next" && args.flags["delete-maps"] && !args.flags["dry-run"]) {
+          const maps = browserSourceMaps((args.multi.dir ?? [])[0] ? (0, import_node_path7.resolve)(cwd, args.multi.dir[0]) : cwd, s(args.flags["dist-dir"]) ?? ".next");
+          for (const m of maps) (0, import_node_fs6.rmSync)(m, { force: true });
+          err(`[argus] deleted ${maps.length} browser source map(s) from the build output`);
+        }
+        return 0;
+      }
+      default:
+        throw new Error(`unknown command "${command}"`);
+    }
+  } catch (e) {
+    err(`argus-build: ${e instanceof Error ? e.message : String(e)}`);
+    return 2;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ARTIFACT_SET_GLOBAL,
+  NEXT_PUBLIC_ENV,
+  NEXT_SERVER_ENV,
+  applyInit,
+  artifactSetPrelude,
+  assertArtifactSetId,
+  browserSourceMaps,
+  buildManifest,
+  classifyArtifact,
+  detectPackageManager,
+  detectProject,
+  formatCommand,
+  injectArtifactSetId,
+  isJsOnlyPlan,
+  isValidArtifactSetId,
+  manifestName,
+  newArtifactSetId,
+  nextArtifactSetIds,
+  nextUrlPrefix,
+  planExpoExport,
+  planFiles,
+  planInit,
+  planNative,
+  planNext,
+  renderInit,
+  resolveArtifactSetId,
+  runCli,
+  runInit,
+  runUploads,
+  uploadArgs,
+  uploadNextBuild,
+  uploadPlanOverHttp,
+  walkFiles,
+  withArgusMetro,
+  withArgusNext,
+  writeArtifactSetModule
+});
+//# sourceMappingURL=index.cjs.map