midline-agent 0.5.0 → 0.6.0

package/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 All notable changes to `midline-agent`, compiled from git history. Dates reflect commit dates, newest first.
 
+## 2026-09-20
+- feat: `midline-agent sourcemaps upload <dir> --release <name>` uploads a build's source maps to Midline
+  so stack traces show original code. Authenticates with a project server API key; browser keys are refused
+  (0.6.0)
+
 ## 2026-09-17
 - feat: `midline-agent/browser` captures pageviews — on load and on every SPA route change — as the
   basis for visitor counting and funnel views in the Midline dashboard (0.5.0)

package/dist/browser/version.d.ts

@@ -1,2 +1,2 @@
 /** Kept in step with package.json by test/browser.test.js; a browser bundle can't read package.json. */
-export declare const BROWSER_SDK_VERSION = "0.5.0";
+export declare const BROWSER_SDK_VERSION = "0.6.0";

package/dist/browser/version.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BROWSER_SDK_VERSION = void 0;
 /** Kept in step with package.json by test/browser.test.js; a browser bundle can't read package.json. */
-exports.BROWSER_SDK_VERSION = "0.5.0";
+exports.BROWSER_SDK_VERSION = "0.6.0";

package/dist/cli.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const agent_1 = require("./agent");
 const config_1 = require("./config");
 const proxy_1 = require("./proxy");
+const sourcemaps_1 = require("./sourcemaps");
 const USAGE = `Usage: midline-agent proxy [--target <url>] [--port <n>] [--host <addr>]
 
 Forwards traffic to a destination API and reports every exchange to Midline.
@@ -17,6 +18,18 @@ Midline server:
   MIDLINE_ENDPOINT     default https://api.usemidline.com
   MIDLINE_CUSTOM_CA    extra CA for the Midline server only (PEM or file path)
   TARGET_API_CA        extra CA for the destination only (PEM or file path)
+
+Usage: midline-agent sourcemaps upload <dir> --release <name> [--url-prefix <prefix>] [--dry-run]
+
+Uploads every .map file under <dir> so stack traces from that release show your
+original code. Run it in CI after your build, with the same release name your SDK
+reports.
+
+  --release      Release the build belongs to        (required)
+  --url-prefix   What the built files are served under (default "~", any origin)
+  --endpoint     Midline server                      (MIDLINE_ENDPOINT)
+  --api-key      A project SERVER key, pk_ keys are refused (MIDLINE_API_KEY)
+  --dry-run      List what would be uploaded
 `;
 function flag(args, name) {
     const index = args.indexOf(`--${name}`);
@@ -25,8 +38,30 @@ function flag(args, name) {
     const inline = args.find((arg) => arg.startsWith(`--${name}=`));
     return inline?.slice(name.length + 3);
 }
+async function sourcemaps(args) {
+    const dir = args[2] && !args[2].startsWith("--") ? args[2] : undefined;
+    if (args[1] !== "upload" || !dir || args.includes("--help") || args.includes("-h")) {
+        process.stdout.write(USAGE);
+        process.exitCode = args.includes("--help") || args.includes("-h") ? 0 : 1;
+        return;
+    }
+    const result = await (0, sourcemaps_1.uploadSourceMaps)({
+        dir,
+        release: flag(args, "release") ?? "",
+        urlPrefix: flag(args, "url-prefix"),
+        endpoint: flag(args, "endpoint"),
+        apiKey: flag(args, "api-key"),
+        dryRun: args.includes("--dry-run"),
+        log: (line) => process.stdout.write(`midline sourcemaps: ${line}\n`),
+    });
+    process.stdout.write(`midline sourcemaps: ${result.uploaded.length} ${args.includes("--dry-run") ? "listed" : "uploaded"}, ${result.failed.length} failed\n`);
+    if (result.failed.length)
+        process.exitCode = 1;
+}
 async function main() {
     const args = process.argv.slice(2);
+    if (args[0] === "sourcemaps")
+        return sourcemaps(args);
     if (args[0] !== "proxy" || args.includes("--help") || args.includes("-h")) {
         process.stdout.write(USAGE);
         process.exitCode = args[0] === "proxy" || args.length === 0 ? 0 : 1;
@@ -58,6 +93,6 @@ async function main() {
     process.on("SIGTERM", () => stop("SIGTERM"));
 }
 main().catch((err) => {
-    process.stderr.write(`midline proxy: ${err instanceof config_1.ConfigError ? err.message : err?.stack ?? err}\n`);
+    process.stderr.write(`midline ${process.argv[2] === "sourcemaps" ? "sourcemaps" : "proxy"}: ${err instanceof config_1.ConfigError ? err.message : err?.stack ?? err}\n`);
     process.exit(1);
 });

package/dist/esm/browser/version.js

@@ -1,2 +1,2 @@
 /** Kept in step with package.json by test/browser.test.js; a browser bundle can't read package.json. */
-export const BROWSER_SDK_VERSION = "0.5.0";
+export const BROWSER_SDK_VERSION = "0.6.0";

package/dist/sourcemaps.d.ts

@@ -0,0 +1,26 @@
+export interface UploadOptions {
+    /** Directory containing the build output (searched recursively for `*.map`). */
+    dir: string;
+    /** The release the build belongs to: the same string passed as `release` to the SDK. */
+    release: string;
+    /** What the built files are served under. Default `~`, meaning "any origin, this path". */
+    urlPrefix?: string;
+    /** Midline server. Env fallback: `MIDLINE_ENDPOINT`. */
+    endpoint?: string;
+    /** A project's **server** API key. Env fallback: `MIDLINE_API_KEY`. Browser keys are refused by the server. */
+    apiKey?: string;
+    dryRun?: boolean;
+    log?: (line: string) => void;
+}
+export interface UploadResult {
+    uploaded: string[];
+    failed: Array<{
+        name: string;
+        error: string;
+    }>;
+}
+/** Every `*.map` under `dir`, without descending into node_modules. */
+export declare function findMaps(dir: string, depth?: number): Promise<string[]>;
+/** `dist/assets/app-3f2a.js.map` -> `~/assets/app-3f2a.js`: the built file the map describes, as the server will match it. */
+export declare function uploadName(dir: string, mapFile: string, urlPrefix?: string): string;
+export declare function uploadSourceMaps(options: UploadOptions): Promise<UploadResult>;

package/dist/sourcemaps.js

@@ -0,0 +1,118 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findMaps = findMaps;
+exports.uploadName = uploadName;
+exports.uploadSourceMaps = uploadSourceMaps;
+const promises_1 = require("fs/promises");
+const path = __importStar(require("path"));
+const config_1 = require("./config");
+const MAX_DEPTH = 20;
+const CONCURRENCY = 4;
+/** Every `*.map` under `dir`, without descending into node_modules. */
+async function findMaps(dir, depth = 0) {
+    if (depth > MAX_DEPTH)
+        return [];
+    const entries = await (0, promises_1.readdir)(dir, { withFileTypes: true });
+    const found = [];
+    for (const entry of entries) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (entry.name !== "node_modules")
+                found.push(...(await findMaps(full, depth + 1)));
+        }
+        else if (entry.isFile() && entry.name.endsWith(".map")) {
+            found.push(full);
+        }
+    }
+    return found.sort();
+}
+/** `dist/assets/app-3f2a.js.map` -> `~/assets/app-3f2a.js`: the built file the map describes, as the server will match it. */
+function uploadName(dir, mapFile, urlPrefix = "~") {
+    const relative = path.relative(dir, mapFile).split(path.sep).join("/").replace(/\.map$/, "");
+    return `${urlPrefix.replace(/\/+$/, "")}/${relative}`;
+}
+async function uploadSourceMaps(options) {
+    const log = options.log ?? (() => undefined);
+    if (!options.release?.trim())
+        throw new config_1.ConfigError("--release is required");
+    const apiKey = options.apiKey ?? (0, config_1.env)("MIDLINE_API_KEY");
+    if (!apiKey && !options.dryRun)
+        throw new config_1.ConfigError("Set MIDLINE_API_KEY (a project server key) or pass --api-key");
+    const origin = (0, config_1.resolveEndpointOrigin)(options.endpoint ?? (0, config_1.env)("MIDLINE_ENDPOINT") ?? config_1.DEFAULT_ENDPOINT);
+    const maps = await findMaps(options.dir).catch((error) => {
+        if (error.code === "ENOENT" || error.code === "ENOTDIR")
+            throw new config_1.ConfigError(`${options.dir} is not a directory`);
+        throw error;
+    });
+    if (!maps.length)
+        throw new config_1.ConfigError(`No .map files found under ${options.dir}. Enable source maps in your build.`);
+    const result = { uploaded: [], failed: [] };
+    const queue = [...maps];
+    const worker = async () => {
+        for (let file = queue.shift(); file; file = queue.shift()) {
+            const name = uploadName(options.dir, file, options.urlPrefix);
+            if (options.dryRun) {
+                log(`would upload ${name}`);
+                result.uploaded.push(name);
+                continue;
+            }
+            try {
+                const body = new FormData();
+                body.append("release", options.release);
+                body.append("name", name);
+                body.append("file", new Blob([await (0, promises_1.readFile)(file)]), path.basename(file));
+                const response = await fetch(new URL("/api/sourcemaps/upload", origin), {
+                    method: "POST",
+                    headers: { "x-midline-key": apiKey },
+                    body,
+                });
+                if (!response.ok) {
+                    const detail = await response.json().catch(() => undefined);
+                    throw new Error(`${response.status} ${detail?.message ?? response.statusText}`);
+                }
+                log(`uploaded ${name}`);
+                result.uploaded.push(name);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                log(`failed   ${name}: ${message}`);
+                result.failed.push({ name, error: message });
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(CONCURRENCY, maps.length) }, worker));
+    return result;
+}

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "midline-agent",
-  "version": "0.5.0",
-  "description": "Midline — request, error and security monitoring for Node, and error, network, Web Vitals and pageview/visitor monitoring for browsers",
+  "version": "0.6.0",
+  "description": "Midline \u2014 request, error and security monitoring for Node, and error, network, Web Vitals and pageview/visitor monitoring for browsers",
+  "homepage": "https://usemidline.com",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -38,16 +39,32 @@
   },
   "keywords": [
     "midline",
+    "api-monitoring",
+    "api-observability",
+    "apm",
+    "browser",
+    "console-capture",
+    "error-tracking",
+    "errors",
     "express",
+    "express-middleware",
+    "frontend",
+    "http-logging",
+    "issue-tracking",
+    "log-redaction",
     "monitoring",
+    "nestjs",
+    "nodejs",
+    "observability",
+    "proxy",
+    "real-user-monitoring",
+    "request",
+    "request-logging",
+    "reverse-proxy",
+    "rum",
     "sdk",
     "security",
-    "request",
-    "errors",
-    "proxy",
-    "browser",
-    "web-vitals",
-    "frontend"
+    "web-vitals"
   ],
   "author": "Your Name",
   "license": "MIT",

package/src/browser/version.ts

@@ -1,2 +1,2 @@
 /** Kept in step with package.json by test/browser.test.js; a browser bundle can't read package.json. */
-export const BROWSER_SDK_VERSION = "0.5.0";
+export const BROWSER_SDK_VERSION = "0.6.0";

package/src/cli.ts

@@ -2,6 +2,7 @@
 import { MidlineAgent } from "./agent";
 import { ConfigError } from "./config";
 import { proxyAddress, resolveTarget, startMidlineProxy } from "./proxy";
+import { uploadSourceMaps } from "./sourcemaps";
 
 const USAGE = `Usage: midline-agent proxy [--target <url>] [--port <n>] [--host <addr>]
 
@@ -16,6 +17,18 @@ Midline server:
   MIDLINE_ENDPOINT     default https://api.usemidline.com
   MIDLINE_CUSTOM_CA    extra CA for the Midline server only (PEM or file path)
   TARGET_API_CA        extra CA for the destination only (PEM or file path)
+
+Usage: midline-agent sourcemaps upload <dir> --release <name> [--url-prefix <prefix>] [--dry-run]
+
+Uploads every .map file under <dir> so stack traces from that release show your
+original code. Run it in CI after your build, with the same release name your SDK
+reports.
+
+  --release      Release the build belongs to        (required)
+  --url-prefix   What the built files are served under (default "~", any origin)
+  --endpoint     Midline server                      (MIDLINE_ENDPOINT)
+  --api-key      A project SERVER key, pk_ keys are refused (MIDLINE_API_KEY)
+  --dry-run      List what would be uploaded
 `;
 
 function flag(args: string[], name: string): string | undefined {
@@ -25,8 +38,29 @@ function flag(args: string[], name: string): string | undefined {
   return inline?.slice(name.length + 3);
 }
 
+async function sourcemaps(args: string[]): Promise<void> {
+  const dir = args[2] && !args[2].startsWith("--") ? args[2] : undefined;
+  if (args[1] !== "upload" || !dir || args.includes("--help") || args.includes("-h")) {
+    process.stdout.write(USAGE);
+    process.exitCode = args.includes("--help") || args.includes("-h") ? 0 : 1;
+    return;
+  }
+  const result = await uploadSourceMaps({
+    dir,
+    release: flag(args, "release") ?? "",
+    urlPrefix: flag(args, "url-prefix"),
+    endpoint: flag(args, "endpoint"),
+    apiKey: flag(args, "api-key"),
+    dryRun: args.includes("--dry-run"),
+    log: (line) => process.stdout.write(`midline sourcemaps: ${line}\n`),
+  });
+  process.stdout.write(`midline sourcemaps: ${result.uploaded.length} ${args.includes("--dry-run") ? "listed" : "uploaded"}, ${result.failed.length} failed\n`);
+  if (result.failed.length) process.exitCode = 1;
+}
+
 async function main(): Promise<void> {
   const args = process.argv.slice(2);
+  if (args[0] === "sourcemaps") return sourcemaps(args);
   if (args[0] !== "proxy" || args.includes("--help") || args.includes("-h")) {
     process.stdout.write(USAGE);
     process.exitCode = args[0] === "proxy" || args.length === 0 ? 0 : 1;
@@ -64,6 +98,6 @@ async function main(): Promise<void> {
 }
 
 main().catch((err) => {
-  process.stderr.write(`midline proxy: ${err instanceof ConfigError ? err.message : err?.stack ?? err}\n`);
+  process.stderr.write(`midline ${process.argv[2] === "sourcemaps" ? "sourcemaps" : "proxy"}: ${err instanceof ConfigError ? err.message : err?.stack ?? err}\n`);
   process.exit(1);
 });

package/src/sourcemaps.ts

@@ -0,0 +1,99 @@
+import { readdir, readFile } from "fs/promises";
+import * as path from "path";
+import { DEFAULT_ENDPOINT, ConfigError, env, resolveEndpointOrigin } from "./config";
+
+export interface UploadOptions {
+  /** Directory containing the build output (searched recursively for `*.map`). */
+  dir: string;
+  /** The release the build belongs to: the same string passed as `release` to the SDK. */
+  release: string;
+  /** What the built files are served under. Default `~`, meaning "any origin, this path". */
+  urlPrefix?: string;
+  /** Midline server. Env fallback: `MIDLINE_ENDPOINT`. */
+  endpoint?: string;
+  /** A project's **server** API key. Env fallback: `MIDLINE_API_KEY`. Browser keys are refused by the server. */
+  apiKey?: string;
+  dryRun?: boolean;
+  log?: (line: string) => void;
+}
+
+export interface UploadResult {
+  uploaded: string[];
+  failed: Array<{ name: string; error: string }>;
+}
+
+const MAX_DEPTH = 20;
+const CONCURRENCY = 4;
+
+/** Every `*.map` under `dir`, without descending into node_modules. */
+export async function findMaps(dir: string, depth = 0): Promise<string[]> {
+  if (depth > MAX_DEPTH) return [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  const found: string[] = [];
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name !== "node_modules") found.push(...(await findMaps(full, depth + 1)));
+    } else if (entry.isFile() && entry.name.endsWith(".map")) {
+      found.push(full);
+    }
+  }
+  return found.sort();
+}
+
+/** `dist/assets/app-3f2a.js.map` -> `~/assets/app-3f2a.js`: the built file the map describes, as the server will match it. */
+export function uploadName(dir: string, mapFile: string, urlPrefix = "~"): string {
+  const relative = path.relative(dir, mapFile).split(path.sep).join("/").replace(/\.map$/, "");
+  return `${urlPrefix.replace(/\/+$/, "")}/${relative}`;
+}
+
+export async function uploadSourceMaps(options: UploadOptions): Promise<UploadResult> {
+  const log = options.log ?? (() => undefined);
+  if (!options.release?.trim()) throw new ConfigError("--release is required");
+  const apiKey = options.apiKey ?? env("MIDLINE_API_KEY");
+  if (!apiKey && !options.dryRun) throw new ConfigError("Set MIDLINE_API_KEY (a project server key) or pass --api-key");
+  const origin = resolveEndpointOrigin(options.endpoint ?? env("MIDLINE_ENDPOINT") ?? DEFAULT_ENDPOINT);
+
+  const maps = await findMaps(options.dir).catch((error: NodeJS.ErrnoException) => {
+    if (error.code === "ENOENT" || error.code === "ENOTDIR") throw new ConfigError(`${options.dir} is not a directory`);
+    throw error;
+  });
+  if (!maps.length) throw new ConfigError(`No .map files found under ${options.dir}. Enable source maps in your build.`);
+
+  const result: UploadResult = { uploaded: [], failed: [] };
+  const queue = [...maps];
+
+  const worker = async () => {
+    for (let file = queue.shift(); file; file = queue.shift()) {
+      const name = uploadName(options.dir, file, options.urlPrefix);
+      if (options.dryRun) {
+        log(`would upload ${name}`);
+        result.uploaded.push(name);
+        continue;
+      }
+      try {
+        const body = new FormData();
+        body.append("release", options.release);
+        body.append("name", name);
+        body.append("file", new Blob([await readFile(file)]), path.basename(file));
+        const response = await fetch(new URL("/api/sourcemaps/upload", origin), {
+          method: "POST",
+          headers: { "x-midline-key": apiKey as string },
+          body,
+        });
+        if (!response.ok) {
+          const detail = await response.json().catch(() => undefined);
+          throw new Error(`${response.status} ${detail?.message ?? response.statusText}`);
+        }
+        log(`uploaded ${name}`);
+        result.uploaded.push(name);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        log(`failed   ${name}: ${message}`);
+        result.failed.push({ name, error: message });
+      }
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(CONCURRENCY, maps.length) }, worker));
+  return result;
+}

package/test/sourcemaps.test.js

@@ -0,0 +1,71 @@
+"use strict";
+
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const fs = require("fs");
+const http = require("http");
+const os = require("os");
+const path = require("path");
+const { findMaps, uploadName, uploadSourceMaps } = require("../dist/sourcemaps");
+
+function makeBuild() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "midline-maps-"));
+  fs.mkdirSync(path.join(dir, "assets"));
+  fs.mkdirSync(path.join(dir, "node_modules", "dep"), { recursive: true });
+  fs.writeFileSync(path.join(dir, "assets", "app-1.js.map"), '{"version":3,"mappings":"AAAA"}');
+  fs.writeFileSync(path.join(dir, "main.js.map"), '{"version":3,"mappings":"AAAA"}');
+  fs.writeFileSync(path.join(dir, "assets", "app-1.js"), "//");
+  fs.writeFileSync(path.join(dir, "node_modules", "dep", "x.js.map"), "{}");
+  return dir;
+}
+
+test("finds .map files, skipping node_modules, and names them by the built file they describe", async () => {
+  const dir = makeBuild();
+  const maps = await findMaps(dir);
+  assert.deepEqual(maps.map((m) => path.relative(dir, m)), [path.join("assets", "app-1.js.map"), "main.js.map"]);
+  assert.equal(uploadName(dir, maps[0]), "~/assets/app-1.js");
+  assert.equal(uploadName(dir, maps[1], "https://app.example.com/static/"), "https://app.example.com/static/main.js");
+  fs.rmSync(dir, { recursive: true, force: true });
+});
+
+test("uploads each map with the key, release and name, and reports failures", async () => {
+  const dir = makeBuild();
+  const seen = [];
+  const server = http.createServer((req, res) => {
+    let body = "";
+    req.on("data", (c) => (body += c));
+    req.on("end", () => {
+      seen.push({ url: req.url, key: req.headers["x-midline-key"], body });
+      const failing = body.includes("main.js");
+      res.writeHead(failing ? 400 : 201, { "content-type": "application/json" });
+      res.end(JSON.stringify(failing ? { message: "That is not a version 3 source map" } : { ok: true }));
+    });
+  });
+  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const endpoint = `http://127.0.0.1:${server.address().port}`;
+
+  const lines = [];
+  const result = await uploadSourceMaps({ dir, release: "1.2.3", endpoint, apiKey: "ak_test", log: (l) => lines.push(l) });
+  server.close();
+
+  assert.equal(seen.length, 2);
+  assert.ok(seen.every((s) => s.url === "/api/sourcemaps/upload" && s.key === "ak_test"));
+  assert.ok(seen.some((s) => s.body.includes("~/assets/app-1.js") && s.body.includes("1.2.3")));
+  assert.deepEqual(result.uploaded, ["~/assets/app-1.js"]);
+  assert.equal(result.failed.length, 1);
+  assert.match(result.failed[0].error, /400 That is not a version 3 source map/);
+  fs.rmSync(dir, { recursive: true, force: true });
+});
+
+test("dry run touches nothing, and misconfiguration fails clearly", async () => {
+  const dir = makeBuild();
+  const dry = await uploadSourceMaps({ dir, release: "1", dryRun: true });
+  assert.equal(dry.uploaded.length, 2);
+  await assert.rejects(uploadSourceMaps({ dir, release: "" }), /--release is required/);
+  await assert.rejects(uploadSourceMaps({ dir, release: "1", apiKey: "k", endpoint: "http://example.com" }), /https/);
+  await assert.rejects(uploadSourceMaps({ dir: os.tmpdir() + "/does-not-exist-midline", release: "1", apiKey: "k", endpoint: "https://api.example.com" }));
+  const empty = fs.mkdtempSync(path.join(os.tmpdir(), "midline-empty-"));
+  await assert.rejects(uploadSourceMaps({ dir: empty, release: "1", apiKey: "k", endpoint: "https://api.example.com" }), /No \.map files/);
+  fs.rmSync(dir, { recursive: true, force: true });
+  fs.rmSync(empty, { recursive: true, force: true });
+});