@getargus/build-tools 0.0.0-stage → 0.3.0

package/dist/next.js

@@ -0,0 +1,582 @@
+// src/next.ts
+import { createRequire } from "module";
+import { join as join2 } from "path";
+
+// src/ids.ts
+import { randomBytes } from "crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+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}$/;
+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 = 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;
+}
+
+// src/next-upload.ts
+import { rmSync } from "fs";
+
+// src/collect.ts
+import { closeSync, existsSync as existsSync2, openSync, readFileSync as readFileSync2, readSync, readdirSync, statSync } from "fs";
+import { basename, dirname as dirname2, join, relative, resolve as resolve2, sep } from "path";
+function classifyArtifact(path) {
+  const lower = 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 = 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 = 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 = 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: 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 = statSync(file).size;
+    const buf = Buffer.alloc(Math.min(size, 1024));
+    const fd = openSync(file, "r");
+    try {
+      readSync(fd, buf, 0, buf.length, size - buf.length);
+    } finally {
+      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 resolve2(dirname2(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 = resolve2(options.projectDir ?? process.cwd());
+  const dist = resolve2(projectDir, options.distDir ?? ".next");
+  if (!existsSync2(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 = existsSync2(join(dist, "static")) ? jsPairs(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 = existsSync2(join(dist, "server")) ? jsPairs(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 = resolve2(projectDir, distDir, "static");
+  return existsSync2(dir) ? walkFiles(dir).filter((f) => f.endsWith(".map")) : [];
+}
+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(sep) ? prefix : prefix + sep)) ? relative(prefix, generated) : basename(generated);
+  return `${plan.urlPrefix ?? ""}${rel.split(sep).join("/").replace(/^\/+/, "")}`;
+}
+function formatCommand(bin, args, cwd = process.cwd()) {
+  const quote = (s) => /^[A-Za-z0-9_./:@=+-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`;
+  const short = (s) => {
+    if (!s.startsWith(cwd + sep)) return s;
+    return relative(cwd, s);
+  };
+  return [bin, ...args.map((a) => quote(short(a)))].join(" ");
+}
+
+// src/upload.ts
+import { spawn } from "child_process";
+
+// src/http-upload.ts
+import { createHash } from "crypto";
+import { createReadStream, openSync as openSync2, readSync as readSync2, closeSync as closeSync2, statSync as statSync2, readFileSync as readFileSync3 } from "fs";
+import { basename as basename2, relative as relative2, sep as sep2 } from "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 = createHash("sha256");
+    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 = openSync2(path, "r");
+  let n = 0;
+  try {
+    n = readSync2(fd, head, 0, head.length, 0);
+  } finally {
+    closeSync2(fd);
+  }
+  if (head.subarray(0, n).includes(needle)) return true;
+  return statSync2(path).size > n && readFileSync3(path).includes(needle);
+}
+function setName(plan, file) {
+  const prefix = plan.stripPrefix;
+  const inside = prefix && (file === prefix || file.startsWith(prefix.endsWith(sep2) ? prefix : prefix + sep2));
+  return (inside ? relative2(prefix, file) : file).split(sep2).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: ${basename2(path)} is a native symbol file; upload it with the argus CLI`);
+    const size = statSync2(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: readFileSync3(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 = 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) 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 } = createRequire(join2(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 withArgus(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);
+}
+export {
+  nextArtifactSetIds,
+  nextUrlPrefix,
+  withArgus
+};
+//# sourceMappingURL=next.js.map