@devkitio/faultlens 0.1.5

package/dist/chunk-P6Q63P6L.js

@@ -0,0 +1,40 @@
+// src/vue/index.ts
+function componentName(instance) {
+  if (typeof instance !== "object" || instance === null || !("$options" in instance)) return void 0;
+  const options = instance.$options;
+  return typeof options?.name === "string" ? options.name : void 0;
+}
+function installVueErrorMonitor(app, monitor) {
+  const original = app.config.errorHandler;
+  const wrapped = (error, instance, info) => {
+    try {
+      return original?.(error, instance, info);
+    } finally {
+      queueMicrotask(() => {
+        try {
+          monitor.captureException(error, {
+            handled: false,
+            mechanism: "vue.errorHandler",
+            context: { info, component: componentName(instance) }
+          });
+        } catch {
+        }
+      });
+    }
+  };
+  app.config.errorHandler = wrapped;
+  return () => {
+    if (app.config.errorHandler !== wrapped) return;
+    if (original) app.config.errorHandler = original;
+    else delete app.config.errorHandler;
+  };
+}
+function createVueErrorMonitorPlugin(monitor) {
+  return {
+    install(app) {
+      installVueErrorMonitor(app, monitor);
+    }
+  };
+}
+
+export { createVueErrorMonitorPlugin, installVueErrorMonitor };

package/dist/chunk-RXQF7F2E.js

@@ -0,0 +1,30 @@
+import { createHash, createHmac } from 'crypto';
+
+// src/nuxt/server-transport.ts
+function createSignedRelayHeaders(config, body, eventId, timestamp = Math.floor(Date.now() / 1e3)) {
+  const url = new URL(config.upstream);
+  if (url.protocol !== "https:" && url.hostname !== "localhost") {
+    throw new Error("Relay \u4E0A\u6E38\u5FC5\u987B\u4F7F\u7528 HTTPS");
+  }
+  const bodySha256 = createHash("sha256").update(body).digest("hex");
+  const canonical = [
+    "POST",
+    url.pathname,
+    String(timestamp),
+    eventId,
+    bodySha256,
+    config.relayKeyVersion
+  ].join("\n");
+  const signature = createHmac("sha256", config.relaySecret).update(canonical).digest("hex");
+  return {
+    "content-type": "application/json",
+    "x-faultlens-key-id": config.relayKeyId,
+    "x-faultlens-key-version": config.relayKeyVersion,
+    "x-faultlens-event-id": eventId,
+    "x-faultlens-timestamp": String(timestamp),
+    "x-faultlens-body-sha256": bodySha256,
+    "x-faultlens-signature": signature
+  };
+}
+
+export { createSignedRelayHeaders };

package/dist/cli/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli/index.js

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+import { lstat, readdir, readFile, writeFile, unlink } from 'fs/promises';
+import path from 'path';
+import { randomUUID, createHash } from 'crypto';
+
+var DEBUG_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var SOURCE_MAP_REFERENCE_PATTERN = /(?:\/\*[#@]\s*sourceMappingURL=.*?\*\/|\/\/[#@]\s*sourceMappingURL=.*?$)/gm;
+var DEBUG_ID_COMMENT_PATTERN = /^\/\/#\s*debugId=[0-9a-f-]{36}\s*$/gim;
+var FAULTLENS_INJECTION_PATTERN = /\n?;\(\(\)=>\{try\{const g=globalThis,s=new Error\(\)\.stack;if\(s\)\{\(g\.__FAULTLENS_DEBUG_IDS__\?\?=\{\}\)\[s\]="[0-9a-f-]{36}"\}\}catch\{\}\}\)\(\);?/g;
+function normalizeSourceMapPath(value) {
+  const posix = value.split(path.sep).join("/");
+  if (!posix || posix.includes("\\") || posix.startsWith("/") || /^[a-zA-Z]:/.test(posix)) {
+    throw new Error(`\u5236\u54C1\u8DEF\u5F84\u65E0\u6548\uFF1A${value}`);
+  }
+  if (posix.split("/").some((part) => part === ".." || part === ".")) {
+    throw new Error(`\u5236\u54C1\u8DEF\u5F84\u5305\u542B\u76EE\u5F55\u7A7F\u8D8A\uFF1A${value}`);
+  }
+  if (path.posix.normalize(posix) !== posix) throw new Error(`\u5236\u54C1\u8DEF\u5F84\u672A\u89C4\u8303\u5316\uFF1A${value}`);
+  return posix;
+}
+async function sourceMapFiles(root, current = root) {
+  const entries = await readdir(current, { withFileTypes: true });
+  const result = [];
+  for (const entry of entries) {
+    const absolute = path.join(current, entry.name);
+    const stats = await lstat(absolute);
+    if (stats.isSymbolicLink()) throw new Error(`\u62D2\u7EDD\u7B26\u53F7\u94FE\u63A5\uFF1A${absolute}`);
+    if (stats.isDirectory()) result.push(...await sourceMapFiles(root, absolute));
+    else if (stats.isFile() && entry.name.endsWith(".map")) result.push(absolute);
+  }
+  return result.sort();
+}
+function runtimeInjection(debugId) {
+  return `;(()=>{try{const g=globalThis,s=new Error().stack;if(s){(g.__FAULTLENS_DEBUG_IDS__??={})[s]="${debugId}"}}catch{}})();
+//# debugId=${debugId}`;
+}
+function correspondingBundle(root, mapPath, document) {
+  const candidate = typeof document.file === "string" && document.file ? path.resolve(path.dirname(mapPath), document.file) : mapPath.slice(0, -4);
+  const resolvedRoot = path.resolve(root);
+  const resolvedCandidate = path.resolve(candidate);
+  if (!resolvedCandidate.startsWith(`${resolvedRoot}${path.sep}`)) {
+    throw new Error(`Source Map \u6307\u5411\u6839\u76EE\u5F55\u4E4B\u5916\u7684\u8FD0\u884C\u5236\u54C1\uFF1A${mapPath}`);
+  }
+  return resolvedCandidate;
+}
+async function prepareOne(root, absolutePath, dryRun) {
+  const originalBody = await readFile(absolutePath);
+  const relativePath = normalizeSourceMapPath(path.relative(root, absolutePath));
+  let document;
+  try {
+    document = JSON.parse(originalBody.toString("utf8"));
+  } catch {
+    throw new Error(`Source Map JSON \u65E0\u6548\uFF1A${relativePath}`);
+  }
+  if (document.version !== 3) throw new Error(`Source Map \u7248\u672C\u4E0D\u53D7\u652F\u6301\uFF1A${relativePath}`);
+  const existingDebugId = document.debug_id ?? document.debugId;
+  if (existingDebugId !== void 0 && (typeof existingDebugId !== "string" || !DEBUG_ID_PATTERN.test(existingDebugId))) {
+    throw new Error(`Source Map Debug ID \u65E0\u6548\uFF1A${relativePath}`);
+  }
+  const debugId = typeof existingDebugId === "string" ? existingDebugId : randomUUID();
+  document.debug_id = debugId;
+  delete document.debugId;
+  const body = Buffer.from(JSON.stringify(document), "utf8");
+  const bundlePath = correspondingBundle(root, absolutePath, document);
+  const bundleStats = await lstat(bundlePath).catch(() => void 0);
+  if (!bundleStats?.isFile() || bundleStats.isSymbolicLink()) {
+    throw new Error(`Source Map \u7F3A\u5C11\u5B89\u5168\u7684\u5BF9\u5E94\u8FD0\u884C\u5236\u54C1\uFF1A${relativePath}`);
+  }
+  const originalBundle = await readFile(bundlePath, "utf8");
+  const cleanedBundle = originalBundle.replace(SOURCE_MAP_REFERENCE_PATTERN, "").replace(FAULTLENS_INJECTION_PATTERN, "").replace(DEBUG_ID_COMMENT_PATTERN, "").trimEnd();
+  const preparedBundle = `${cleanedBundle}
+${runtimeInjection(debugId)}
+`;
+  if (!dryRun) {
+    await writeFile(absolutePath, body, { mode: 384 });
+    await writeFile(bundlePath, preparedBundle, { mode: 384 });
+  }
+  return {
+    absolutePath,
+    relativePath,
+    sha256: createHash("sha256").update(body).digest("hex"),
+    size: body.byteLength,
+    debugId,
+    body
+  };
+}
+async function prepareSourceMapArtifacts(root, dryRun) {
+  const resolvedRoot = path.resolve(root);
+  const rootStats = await lstat(resolvedRoot);
+  if (!rootStats.isDirectory() || rootStats.isSymbolicLink()) throw new Error("--root \u5FC5\u987B\u662F\u771F\u5B9E\u76EE\u5F55");
+  return Promise.all((await sourceMapFiles(resolvedRoot)).map((file) => prepareOne(resolvedRoot, file, dryRun)));
+}
+async function removeUploadedSourceMaps(artifacts) {
+  for (const artifact of artifacts) await unlink(artifact.absolutePath);
+}
+
+// src/cli/index.ts
+function argument(name) {
+  const index = process.argv.indexOf(name);
+  return index >= 0 ? process.argv[index + 1] : void 0;
+}
+function required(value, label) {
+  if (!value) throw new Error(`\u7F3A\u5C11 ${label}`);
+  return value;
+}
+function environment(name, legacyName) {
+  return process.env[name] ?? process.env[legacyName];
+}
+function options() {
+  return {
+    endpoint: required(argument("--endpoint") ?? environment("FAULTLENS_SOURCEMAP_ENDPOINT", "MOQU_SOURCEMAP_ENDPOINT"), "--endpoint"),
+    token: required(argument("--token") ?? environment("FAULTLENS_SOURCEMAP_TOKEN", "MOQU_SOURCEMAP_TOKEN"), "--token \u6216 FAULTLENS_SOURCEMAP_TOKEN"),
+    root: path.resolve(required(argument("--root") ?? environment("FAULTLENS_SOURCEMAP_ROOT", "MOQU_SOURCEMAP_ROOT"), "--root \u6216 FAULTLENS_SOURCEMAP_ROOT")),
+    release: required(argument("--release") ?? environment("FAULTLENS_RELEASE", "MOQU_RELEASE"), "--release \u6216 FAULTLENS_RELEASE"),
+    environment: required(
+      argument("--environment") ?? environment("FAULTLENS_ENVIRONMENT", "MOQU_ENVIRONMENT"),
+      "--environment \u6216 FAULTLENS_ENVIRONMENT"
+    ),
+    dist: argument("--dist") ?? environment("FAULTLENS_DIST", "MOQU_DIST") ?? "default",
+    dryRun: process.argv.includes("--dry-run"),
+    deleteAfterVerify: process.argv.includes("--delete-after-verify")
+  };
+}
+async function upload(config, artifacts) {
+  if (config.dryRun) {
+    console.info(`\u6F14\u7EC3\u5B8C\u6210\uFF1A\u5C06\u4E0A\u4F20 ${artifacts.length} \u4E2A Source Map \u6587\u4EF6`);
+    return;
+  }
+  for (const current of artifacts) {
+    const response = await fetch(`${config.endpoint.replace(/\/$/, "")}/v1/admin/source-maps/artifacts`, {
+      method: "PUT",
+      headers: {
+        authorization: `Bearer ${config.token}`,
+        "content-type": "application/octet-stream",
+        "x-faultlens-release": config.release,
+        "x-faultlens-environment": config.environment,
+        "x-faultlens-dist": config.dist,
+        "x-faultlens-artifact-path": current.relativePath,
+        "x-faultlens-debug-id": current.debugId,
+        "x-faultlens-sha256": current.sha256,
+        "x-faultlens-size": String(current.size)
+      },
+      body: current.body.buffer.slice(
+        current.body.byteOffset,
+        current.body.byteOffset + current.body.byteLength
+      ),
+      redirect: "error"
+    });
+    if (!response.ok) throw new Error(`\u4E0A\u4F20\u5931\u8D25\uFF1A${current.relativePath}\uFF0C\u72B6\u6001\u7801 ${response.status}`);
+  }
+  console.info(`\u4E0A\u4F20\u5B8C\u6210\uFF1A${artifacts.length} \u4E2A Source Map \u6587\u4EF6`);
+}
+async function verify(config, artifacts) {
+  const response = await fetch(`${config.endpoint.replace(/\/$/, "")}/v1/admin/source-maps/verify`, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${config.token}`,
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      release: config.release,
+      environment: config.environment,
+      dist: config.dist,
+      artifacts: artifacts.map(({ relativePath, sha256, size, debugId }) => ({
+        path: relativePath,
+        sha256,
+        size,
+        debugId
+      }))
+    }),
+    redirect: "error"
+  });
+  if (!response.ok) throw new Error(`\u5236\u54C1\u6E05\u5355\u6821\u9A8C\u5931\u8D25\uFF0C\u72B6\u6001\u7801 ${response.status}`);
+  if (config.deleteAfterVerify) await removeUploadedSourceMaps(artifacts);
+  console.info("Source Map \u5236\u54C1\u6E05\u5355\u4E0E\u670D\u52A1\u7AEF\u4E00\u81F4");
+}
+async function doctor(config) {
+  const url = new URL(config.endpoint);
+  if (url.protocol !== "https:" && url.hostname !== "localhost") throw new Error("\u670D\u52A1\u5730\u5740\u5FC5\u987B\u4F7F\u7528 HTTPS");
+  if (process.versions.node.split(".")[0] !== "22") {
+    console.warn(`\u5F53\u524D Node.js \u4E3A ${process.version}\uFF0C\u751F\u4EA7 CI \u5E94\u4F7F\u7528 Node.js 22`);
+  }
+  await lstat(config.root);
+  console.info("CLI \u914D\u7F6E\u68C0\u67E5\u901A\u8FC7");
+}
+async function main() {
+  const command = process.argv[2];
+  const subcommand = process.argv[3];
+  const config = options();
+  if (command === "doctor") return doctor(config);
+  if (command !== "sourcemaps" || !["upload", "verify"].includes(subcommand ?? "")) {
+    throw new Error("\u7528\u6CD5\uFF1Afaultlens sourcemaps <upload|verify> [\u53C2\u6570]\uFF0C\u6216 faultlens doctor [\u53C2\u6570]");
+  }
+  const artifacts = await prepareSourceMapArtifacts(config.root, config.dryRun);
+  if (subcommand === "upload") return upload(config, artifacts);
+  if (config.dryRun) {
+    console.info(`\u6F14\u7EC3\u5B8C\u6210\uFF1A\u5C06\u6821\u9A8C ${artifacts.length} \u4E2A Source Map \u6587\u4EF6`);
+    return;
+  }
+  return verify(config, artifacts);
+}
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : "CLI \u6267\u884C\u5931\u8D25");
+  process.exitCode = 1;
+});

package/dist/express/index.d.ts

@@ -0,0 +1,13 @@
+import { E as ErrorMonitor } from '../types-DxONWOH8.js';
+
+interface ExpressRequestLike {
+    method?: unknown;
+    route?: {
+        path?: unknown;
+    };
+}
+type ExpressNextFunction = (error?: unknown) => void;
+type ExpressErrorMiddleware = (error: unknown, request: ExpressRequestLike, response: unknown, next: ExpressNextFunction) => void;
+declare function createExpressErrorMiddleware(monitor: ErrorMonitor): ExpressErrorMiddleware;
+
+export { type ExpressErrorMiddleware, type ExpressNextFunction, type ExpressRequestLike, createExpressErrorMiddleware };

package/dist/express/index.js

@@ -0,0 +1,22 @@
+// src/express/index.ts
+function requestTags(request) {
+  const tags = {};
+  if (typeof request.method === "string") tags.method = request.method.slice(0, 32);
+  if (typeof request.route?.path === "string") tags.route = request.route.path.slice(0, 512);
+  return tags;
+}
+function createExpressErrorMiddleware(monitor) {
+  return (error, request, _response, next) => {
+    try {
+      monitor.captureException(error, {
+        handled: false,
+        mechanism: "express.error",
+        tags: requestTags(request)
+      });
+    } finally {
+      next(error);
+    }
+  };
+}
+
+export { createExpressErrorMiddleware };

package/dist/fastify/index.d.ts

@@ -0,0 +1,19 @@
+import { E as ErrorMonitor } from '../types-DxONWOH8.js';
+
+interface FaultLensFastifyPluginOptions {
+    monitor: ErrorMonitor;
+    flushTimeoutMs?: number;
+}
+interface FastifyRequestLike {
+    method?: unknown;
+    routeOptions?: {
+        url?: unknown;
+    };
+}
+type FastifyHook = ((request: FastifyRequestLike, reply: unknown, error: unknown) => void | Promise<void>) | (() => void | Promise<void>);
+interface FastifyInstanceLike {
+    addHook(name: string, hook: FastifyHook): unknown;
+}
+declare function faultLensFastifyPlugin(app: FastifyInstanceLike, options: FaultLensFastifyPluginOptions): Promise<void>;
+
+export { type FaultLensFastifyPluginOptions, faultLensFastifyPlugin as default, faultLensFastifyPlugin };

package/dist/fastify/index.js

@@ -0,0 +1,28 @@
+// src/fastify/index.ts
+function requestTags(request) {
+  const tags = {};
+  if (typeof request.method === "string") tags.method = request.method.slice(0, 32);
+  if (typeof request.routeOptions?.url === "string") {
+    tags.route = request.routeOptions.url.slice(0, 512);
+  }
+  return tags;
+}
+async function faultLensFastifyPlugin(app, options) {
+  const flushTimeoutMs = Math.min(3e4, Math.max(0, options.flushTimeoutMs ?? 2e3));
+  app.addHook("onError", async (request, _reply, error) => {
+    options.monitor.captureException(error, {
+      handled: false,
+      mechanism: "fastify.error",
+      tags: requestTags(request)
+    });
+  });
+  app.addHook("onClose", async () => {
+    try {
+      await options.monitor.flush(flushTimeoutMs);
+    } catch {
+    }
+  });
+}
+var fastify_default = faultLensFastifyPlugin;
+
+export { fastify_default as default, faultLensFastifyPlugin };

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { M as MonitorOptions, E as ErrorMonitor } from './types-DxONWOH8.js';
+export { B as Breadcrumb, C as CaptureOptions, a as ContextMode, I as IngestConfig, b as MonitorStatus } from './types-DxONWOH8.js';
+
+declare function createErrorMonitor(options: MonitorOptions): ErrorMonitor;
+
+export { ErrorMonitor, MonitorOptions, createErrorMonitor };

package/dist/index.js

@@ -0,0 +1,2 @@
+export { createErrorMonitor } from './chunk-K63I3OJT.js';
+import './chunk-LRHXSFK2.js';

package/dist/node/index.d.ts

@@ -0,0 +1,34 @@
+import { M as MonitorOptions, c as EventTransport, d as EventEnvelope, T as TransportOutcome, R as RuntimeDependencies, E as ErrorMonitor } from '../types-DxONWOH8.js';
+
+interface NodeRelayIngestConfig {
+    mode: "relay";
+    endpoint: string;
+    keyId: string;
+    keyVersion: string;
+    secret: string;
+}
+interface NodeMonitorOptions extends Omit<MonitorOptions, "ingest"> {
+    ingest: NodeRelayIngestConfig;
+    captureGlobalErrors?: boolean;
+}
+interface NodeRelayTransportOptions {
+    fetcher?: typeof fetch;
+    maxAttempts?: number;
+    retryBaseMs?: number;
+    requestTimeoutMs?: number;
+}
+declare class NodeRelayTransport implements EventTransport {
+    private readonly ingest;
+    private readonly fetcher;
+    private readonly maxAttempts;
+    private readonly retryBaseMs;
+    private readonly requestTimeoutMs;
+    private readonly endpoint;
+    constructor(ingest: NodeRelayIngestConfig, options?: NodeRelayTransportOptions);
+    send(envelope: EventEnvelope): Promise<TransportOutcome>;
+}
+declare function createNodeErrorMonitor(options: NodeMonitorOptions, overrides?: {
+    transport?: EventTransport;
+} & Partial<RuntimeDependencies>): ErrorMonitor;
+
+export { type NodeMonitorOptions, type NodeRelayIngestConfig, NodeRelayTransport, type NodeRelayTransportOptions, createNodeErrorMonitor };

package/dist/node/index.js

@@ -0,0 +1,117 @@
+import { createMonitorRuntime } from '../chunk-LRHXSFK2.js';
+import { createSignedRelayHeaders } from '../chunk-RXQF7F2E.js';
+
+// src/node/index.ts
+function retryAfter(response) {
+  const value = response.headers.get("retry-after");
+  return value && /^\d+$/.test(value) ? Number(value) * 1e3 : void 0;
+}
+function delay(timeoutMs) {
+  return new Promise((resolve) => setTimeout(resolve, timeoutMs));
+}
+var NodeRelayTransport = class {
+  constructor(ingest, options = {}) {
+    this.ingest = ingest;
+    const endpoint = new URL(ingest.endpoint);
+    const local = endpoint.hostname === "localhost" || endpoint.hostname === "127.0.0.1";
+    if (endpoint.protocol !== "https:" && !(endpoint.protocol === "http:" && local)) {
+      throw new Error("Node Relay Endpoint \u5FC5\u987B\u4F7F\u7528 HTTPS");
+    }
+    if (endpoint.pathname !== "/v1/relay/envelope" || endpoint.username || endpoint.password || endpoint.search || endpoint.hash) {
+      throw new Error("Node Relay Endpoint \u683C\u5F0F\u65E0\u6548");
+    }
+    if (!ingest.keyId || !ingest.keyVersion || !ingest.secret) {
+      throw new Error("Node Relay \u51ED\u636E\u4E0D\u5B8C\u6574");
+    }
+    this.endpoint = endpoint.toString();
+    this.fetcher = options.fetcher ?? fetch;
+    this.maxAttempts = Math.min(8, Math.max(1, options.maxAttempts ?? 3));
+    this.retryBaseMs = Math.min(3e4, Math.max(1, options.retryBaseMs ?? 250));
+    this.requestTimeoutMs = Math.min(12e4, Math.max(100, options.requestTimeoutMs ?? 5e3));
+  }
+  fetcher;
+  maxAttempts;
+  retryBaseMs;
+  requestTimeoutMs;
+  endpoint;
+  async send(envelope) {
+    const body = JSON.stringify(envelope);
+    const eventId = envelope.events[0]?.eventId;
+    if (!eventId) return { kind: "permanent_error", code: "empty_envelope" };
+    for (let attempt = 0; attempt < this.maxAttempts; attempt += 1) {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), this.requestTimeoutMs);
+      try {
+        const response = await this.fetcher(this.endpoint, {
+          method: "POST",
+          headers: createSignedRelayHeaders({
+            upstream: this.endpoint,
+            relayKeyId: this.ingest.keyId,
+            relayKeyVersion: this.ingest.keyVersion,
+            relaySecret: this.ingest.secret
+          }, body, eventId),
+          body,
+          cache: "no-store",
+          redirect: "error",
+          signal: controller.signal
+        });
+        if (response.status === 202) return { kind: "accepted" };
+        if (response.status !== 429 && response.status < 500) {
+          let code = `http_${response.status}`;
+          try {
+            const value = await response.json();
+            if (typeof value.code === "string") code = value.code;
+          } catch {
+          }
+          return { kind: "permanent_error", code };
+        }
+        const waitMs = retryAfter(response) ?? Math.min(3e4, this.retryBaseMs * 2 ** attempt);
+        if (attempt + 1 >= this.maxAttempts) return { kind: "retryable", retryAfterMs: waitMs };
+        await delay(waitMs);
+      } catch {
+        if (attempt + 1 >= this.maxAttempts) return { kind: "network_error" };
+        await delay(Math.min(3e4, this.retryBaseMs * 2 ** attempt));
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+    return { kind: "network_error" };
+  }
+};
+function createNodeErrorMonitor(options, overrides = {}) {
+  const { captureGlobalErrors = true, ingest, ...monitorOptions } = options;
+  const monitor = createMonitorRuntime(
+    {
+      ...monitorOptions,
+      ingest: { mode: "relay", endpoint: ingest.endpoint }
+    },
+    {
+      ...overrides,
+      transport: overrides.transport ?? new NodeRelayTransport(ingest)
+    }
+  );
+  if (!captureGlobalErrors) return monitor;
+  const onUncaughtException = (error) => {
+    monitor.captureException(error, {
+      handled: false,
+      mechanism: "node.uncaught_exception"
+    });
+  };
+  const onUnhandledRejection = (reason) => {
+    monitor.captureException(reason, {
+      handled: false,
+      mechanism: "node.unhandled_rejection"
+    });
+  };
+  process.on("uncaughtExceptionMonitor", onUncaughtException);
+  process.on("unhandledRejection", onUnhandledRejection);
+  const close = monitor.close;
+  monitor.close = async () => {
+    process.off("uncaughtExceptionMonitor", onUncaughtException);
+    process.off("unhandledRejection", onUnhandledRejection);
+    return close();
+  };
+  return monitor;
+}
+
+export { NodeRelayTransport, createNodeErrorMonitor };

package/dist/nuxt/index.d.ts

@@ -0,0 +1,23 @@
+import { NuxtModule } from '@nuxt/schema';
+
+interface RelayRuntimeConfig {
+    upstream: string;
+    relayKeyId: string;
+    relayKeyVersion: string;
+    relaySecret: string;
+}
+declare function createSignedRelayHeaders(config: RelayRuntimeConfig, body: string, eventId: string, timestamp?: number): Record<string, string>;
+
+interface FaultLensNuxtModuleOptions {
+    environment: string;
+    release: string;
+    dist?: string;
+    relayEndpoint?: string;
+    upstream?: string;
+    relayKeyId?: string;
+    relayKeyVersion?: string;
+    relaySecret?: string;
+}
+declare const faultLensNuxtModule: NuxtModule<FaultLensNuxtModuleOptions>;
+
+export { type FaultLensNuxtModuleOptions, createSignedRelayHeaders, faultLensNuxtModule as default };

package/dist/nuxt/index.js

@@ -0,0 +1,52 @@
+export { createSignedRelayHeaders } from '../chunk-RXQF7F2E.js';
+import { defineNuxtModule, createResolver, addPlugin, addServerHandler, addServerPlugin } from '@nuxt/kit';
+
+var faultLensNuxtModule = defineNuxtModule({
+  meta: {
+    name: "@devkitio/faultlens",
+    configKey: "faultLens",
+    compatibility: { nuxt: ">=4.0.0" }
+  },
+  defaults: {
+    environment: "development",
+    release: "nuxt@0.0.0+development",
+    dist: "default",
+    relayEndpoint: "/__faultlens/envelope",
+    relayKeyVersion: "v1"
+  },
+  setup(options, nuxt) {
+    const resolver = createResolver(import.meta.url);
+    nuxt.options.runtimeConfig.public.faultLens = {
+      environment: options.environment,
+      release: options.release,
+      dist: options.dist,
+      relayEndpoint: options.relayEndpoint
+    };
+    nuxt.options.runtimeConfig.faultLens = {
+      environment: options.environment,
+      release: options.release,
+      dist: options.dist,
+      upstream: options.upstream,
+      relayKeyId: options.relayKeyId,
+      relayKeyVersion: options.relayKeyVersion,
+      relaySecret: options.relaySecret
+    };
+    addPlugin({
+      src: resolver.resolve("./runtime/plugin"),
+      mode: "client",
+      order: -100
+    });
+    addServerHandler({
+      route: options.relayEndpoint ?? "/__faultlens/envelope",
+      handler: resolver.resolve("./runtime/server-handler")
+    });
+    addServerHandler({
+      route: `${options.relayEndpoint ?? "/__faultlens/envelope"}/config`,
+      handler: resolver.resolve("./runtime/config-handler")
+    });
+    addServerPlugin(resolver.resolve("./runtime/nitro-plugin"));
+  }
+});
+var nuxt_default = faultLensNuxtModule;
+
+export { nuxt_default as default };

package/dist/nuxt/runtime/config-handler.d.ts

@@ -0,0 +1,5 @@
+import * as h3 from 'h3';
+
+declare const _default: h3.EventHandler<h3.EventHandlerRequest, Promise<unknown>>;
+
+export { _default as default };

package/dist/nuxt/runtime/config-handler.js

@@ -0,0 +1,32 @@
+import { defineEventHandler, setResponseStatus, setResponseHeader } from 'h3';
+
+// src/nuxt/runtime/config-handler.ts
+var config_handler_default = defineEventHandler(async (event) => {
+  const runtime = useRuntimeConfig(event).faultLens;
+  if (!runtime.upstream || !runtime.relayKeyId || !runtime.relayKeyVersion) {
+    setResponseStatus(event, 503);
+    return { code: "relay_not_configured" };
+  }
+  try {
+    const upstream = new URL(runtime.upstream);
+    upstream.pathname = "/v1/relay/config";
+    upstream.search = "";
+    const response = await fetch(upstream, {
+      method: "GET",
+      headers: {
+        "x-faultlens-key-id": runtime.relayKeyId,
+        "x-faultlens-key-version": runtime.relayKeyVersion
+      },
+      redirect: "error",
+      cache: "no-store"
+    });
+    setResponseStatus(event, response.status);
+    setResponseHeader(event, "cache-control", "no-store");
+    return await response.json();
+  } catch {
+    setResponseStatus(event, 503);
+    return { code: "relay_unavailable" };
+  }
+});
+
+export { config_handler_default as default };

package/dist/nuxt/runtime/nitro-plugin.d.ts

@@ -0,0 +1,3 @@
+declare const _default: unknown;
+
+export { _default as default };