@autter/runtime-next 1.4.0 → 1.6.0

package/dist/index.cjs

@@ -20,54 +20,231 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  CODE_PATTERN: () => import_runtime_node2.CODE_PATTERN,
+  RuntimeError: () => import_runtime_node2.RuntimeError,
+  addBreadcrumb: () => import_runtime_node2.addBreadcrumb,
+  autterErrorHandler: () => import_runtime_node2.autterErrorHandler,
+  autterErrorResponse: () => import_runtime_node2.autterErrorResponse,
+  autterFastify: () => import_runtime_node2.autterFastify,
+  autterFastifyErrors: () => import_runtime_node2.autterFastifyErrors,
+  autterKoa: () => import_runtime_node2.autterKoa,
+  autterRequests: () => import_runtime_node2.autterRequests,
+  captureRequestError: () => import_runtime_node2.captureRequestError,
   captureServerException: () => import_runtime_node2.captureException,
   captureServerMessage: () => import_runtime_node2.captureMessage,
+  consoleSink: () => import_runtime_node2.consoleSink,
   createAutterRelayRoute: () => createAutterRelayRoute,
   createRuntimeLogger: () => import_runtime_node2.createRuntimeLogger,
+  defineRuntimeErrors: () => import_runtime_node2.defineRuntimeErrors,
   emitLlmSelftestTrace: () => import_runtime_node2.emitLlmSelftestTrace,
+  enrichDeployment: () => import_runtime_node2.enrichDeployment,
+  enrichEdgeGeo: () => import_runtime_node2.enrichEdgeGeo,
+  enrichRequestSize: () => import_runtime_node2.enrichRequestSize,
+  enrichUserAgent: () => import_runtime_node2.enrichUserAgent,
+  errorAttributes: () => import_runtime_node2.errorAttributes,
+  fileSink: () => import_runtime_node2.fileSink,
   flushRuntimeLogs: () => import_runtime_node2.flushRuntimeLogs,
+  initAutterLogging: () => import_runtime_node2.initAutterLogging,
   installAutterAutoFlush: () => import_runtime_node2.installAutterAutoFlush,
   instrumentLlmClient: () => import_runtime_node2.instrumentLlmClient,
+  isRuntimeErrorLike: () => import_runtime_node2.isRuntimeErrorLike,
   makeSafeCapture: () => import_runtime_node2.makeSafeCapture,
+  otlpSink: () => import_runtime_node2.otlpSink,
   redactAttributes: () => import_runtime_node2.redactAttributes,
+  redactText: () => import_runtime_node2.redactText,
   registerAutter: () => registerAutter,
   reportServerOutcome: () => import_runtime_node2.reportOutcome,
+  runInBackground: () => import_runtime_node2.runInBackground,
+  runtimeContext: () => import_runtime_node2.runtimeContext,
   runtimeLogStats: () => import_runtime_node2.runtimeLogStats,
   runtimeLogger: () => import_runtime_node2.runtimeLogger,
+  toClientError: () => import_runtime_node2.toClientError,
   trackLlmCall: () => import_runtime_node2.trackLlmCall,
   withLlmCall: () => import_runtime_node2.withLlmCall,
   withProcessSpan: () => import_runtime_node2.withProcessSpan,
-  withRuntimeOperation: () => import_runtime_node2.withRuntimeOperation
+  withRuntimeOperation: () => import_runtime_node2.withRuntimeOperation,
+  withRuntimeRequest: () => withRuntimeRequest
 });
 module.exports = __toCommonJS(src_exports);
 
 // src/server.ts
 var import_runtime_node = require("@autter/runtime-node");
+
+// package.json
+var package_default = {
+  name: "@autter/runtime-next",
+  version: "1.6.0",
+  description: "One-command Autter Runtime for Next.js: server OTel, request wide events, coded errors, browser tracker, relay route, edge middleware and React error boundary",
+  license: "MIT",
+  type: "module",
+  main: "./dist/index.cjs",
+  module: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js",
+      require: "./dist/index.cjs"
+    },
+    "./server": {
+      types: "./dist/server.d.ts",
+      import: "./dist/server.js",
+      require: "./dist/server.cjs"
+    },
+    "./client": {
+      types: "./dist/client.d.ts",
+      import: "./dist/client.js",
+      require: "./dist/client.cjs"
+    },
+    "./edge": {
+      types: "./dist/edge.d.ts",
+      import: "./dist/edge.js",
+      require: "./dist/edge.cjs"
+    },
+    "./instrumentation": {
+      types: "./dist/instrumentation.d.ts",
+      "edge-light": {
+        import: "./dist/instrumentation-edge.js",
+        require: "./dist/instrumentation-edge.cjs"
+      },
+      worker: {
+        import: "./dist/instrumentation-edge.js",
+        require: "./dist/instrumentation-edge.cjs"
+      },
+      import: "./dist/instrumentation.js",
+      require: "./dist/instrumentation.cjs"
+    }
+  },
+  files: [
+    "dist"
+  ],
+  repository: {
+    type: "git",
+    url: "https://github.com/Autter-dev/autter-runtime.git",
+    directory: "packages/runtime-next"
+  },
+  scripts: {
+    build: `node ../../scripts/ensure-built.mjs runtime-node runtime-edge runtime-browser && node -e "require('node:fs').rmSync('dist',{recursive:true,force:true})" && tsup`,
+    test: "npm run build -w @autter/runtime-core && npm run build -w @autter/runtime-node && npm run build -w @autter/runtime-edge && npm run build -w @autter/runtime-browser && npm run build && node --test test/*.test.mjs"
+  },
+  dependencies: {
+    "@autter/runtime-browser": "^1.6.0",
+    "@autter/runtime-edge": "^1.1.0",
+    "@autter/runtime-node": "^1.6.0"
+  },
+  peerDependencies: {
+    react: ">=18"
+  },
+  devDependencies: {
+    "@types/react": "^18.3.0",
+    tsup: "^8.3.5",
+    typescript: "^5.7.0"
+  },
+  engines: {
+    node: ">=20"
+  },
+  publishConfig: {
+    access: "public",
+    provenance: true
+  },
+  homepage: "https://github.com/Autter-dev/autter-runtime#readme",
+  bugs: "https://github.com/Autter-dev/autter-runtime/issues",
+  keywords: [
+    "nextjs",
+    "error-tracking",
+    "telemetry",
+    "opentelemetry",
+    "react",
+    "error-boundary"
+  ]
+};
+
+// src/server.ts
 var import_runtime_node2 = require("@autter/runtime-node");
 function registerAutter(options) {
-  return (0, import_runtime_node.initAutterServer)(options);
+  return (0, import_runtime_node.initAutterServer)({
+    distro: { name: "@autter/runtime-next", version: package_default.version },
+    ...options
+  });
 }
 function createAutterRelayRoute(options) {
   return { POST: (0, import_runtime_node.createBrowserRelayFetchHandler)(options) };
 }
+var after;
+var afterReady = (async () => {
+  try {
+    const specifier = "next/server";
+    const mod = await import(
+      /* webpackIgnore: true */
+      specifier
+    );
+    after = mod.after ?? mod.unstable_after ?? null;
+  } catch {
+    after = null;
+  }
+  return after;
+})();
+function scheduleAfter(promise) {
+  const run = (fn) => {
+    if (!fn) return;
+    try {
+      fn(promise);
+    } catch {
+    }
+  };
+  if (after !== void 0) run(after);
+  else void afterReady.then(run);
+}
+function withRuntimeRequest(handler, options = {}) {
+  return (0, import_runtime_node.withRuntimeRequest)(handler, {
+    ...options,
+    waitUntil: options.waitUntil ?? scheduleAfter
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CODE_PATTERN,
+  RuntimeError,
+  addBreadcrumb,
+  autterErrorHandler,
+  autterErrorResponse,
+  autterFastify,
+  autterFastifyErrors,
+  autterKoa,
+  autterRequests,
+  captureRequestError,
   captureServerException,
   captureServerMessage,
+  consoleSink,
   createAutterRelayRoute,
   createRuntimeLogger,
+  defineRuntimeErrors,
   emitLlmSelftestTrace,
+  enrichDeployment,
+  enrichEdgeGeo,
+  enrichRequestSize,
+  enrichUserAgent,
+  errorAttributes,
+  fileSink,
   flushRuntimeLogs,
+  initAutterLogging,
   installAutterAutoFlush,
   instrumentLlmClient,
+  isRuntimeErrorLike,
   makeSafeCapture,
+  otlpSink,
   redactAttributes,
+  redactText,
   registerAutter,
   reportServerOutcome,
+  runInBackground,
+  runtimeContext,
   runtimeLogStats,
   runtimeLogger,
+  toClientError,
   trackLlmCall,
   withLlmCall,
   withProcessSpan,
-  withRuntimeOperation
+  withRuntimeOperation,
+  withRuntimeRequest
 });

package/dist/index.d.cts

@@ -1,2 +1,2 @@
-export { createAutterRelayRoute, registerAutter } from './server.cjs';
-export { AutoFlushHandle, AutoFlushOptions, AutterServer, AutterServerOptions, FlushTarget, InstrumentLlmOptions, LlmCallHandle, LlmCallInfo, LlmUsage, RedactOptions, RelayOptions, RuntimeLogContext, RuntimeLogContextValue, RuntimeLogLevel, RuntimeLoggingOptions, RuntimeOperation, RuntimeOutcome, SafeCapture, TrackedLlmCall, captureException as captureServerException, captureMessage as captureServerMessage, createRuntimeLogger, emitLlmSelftestTrace, flushRuntimeLogs, installAutterAutoFlush, instrumentLlmClient, makeSafeCapture, redactAttributes, reportOutcome as reportServerOutcome, runtimeLogStats, runtimeLogger, trackLlmCall, withLlmCall, withProcessSpan, withRuntimeOperation } from '@autter/runtime-node';
+export { createAutterRelayRoute, registerAutter, withRuntimeRequest } from './server.cjs';
+export { AutoFlushHandle, AutoFlushOptions, AutterErrorHandlerOptions, AutterErrorResponseOptions, AutterLogging, AutterLoggingOptions, AutterRequestsOptions, AutterServer, AutterServerOptions, Breadcrumb, BreadcrumbInput, CODE_PATTERN, ClientErrorBody, ConsoleSinkOptions, FileSinkOptions, FlushTarget, InstrumentLlmOptions, LlmCallHandle, LlmCallInfo, LlmUsage, OtlpSinkOptions, RedactOptions, RelayOptions, RuntimeCarrier, RuntimeContextHandle, RuntimeEnrichContext, RuntimeEnrichEvent, RuntimeEnricher, RuntimeError, RuntimeErrorCatalog, RuntimeErrorDefinition, RuntimeErrorExtras, RuntimeErrorFactory, RuntimeErrorLike, RuntimeErrorOptions, RuntimeEvent, RuntimeLogContext, RuntimeLogContextValue, RuntimeLogLevel, RuntimeLoggingOptions, RuntimeOperation, RuntimeOperationKind, RuntimeOperationOptions, RuntimeOutcome, RuntimeRequestOptions, RuntimeSink, RuntimeSinkContext, SafeCapture, TrackedLlmCall, addBreadcrumb, autterErrorHandler, autterErrorResponse, autterFastify, autterFastifyErrors, autterKoa, autterRequests, captureRequestError, captureException as captureServerException, captureMessage as captureServerMessage, consoleSink, createRuntimeLogger, defineRuntimeErrors, emitLlmSelftestTrace, enrichDeployment, enrichEdgeGeo, enrichRequestSize, enrichUserAgent, errorAttributes, fileSink, flushRuntimeLogs, initAutterLogging, installAutterAutoFlush, instrumentLlmClient, isRuntimeErrorLike, makeSafeCapture, otlpSink, redactAttributes, redactText, reportOutcome as reportServerOutcome, runInBackground, runtimeContext, runtimeLogStats, runtimeLogger, toClientError, trackLlmCall, withLlmCall, withProcessSpan, withRuntimeOperation } from '@autter/runtime-node';

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export { createAutterRelayRoute, registerAutter } from './server.js';
-export { AutoFlushHandle, AutoFlushOptions, AutterServer, AutterServerOptions, FlushTarget, InstrumentLlmOptions, LlmCallHandle, LlmCallInfo, LlmUsage, RedactOptions, RelayOptions, RuntimeLogContext, RuntimeLogContextValue, RuntimeLogLevel, RuntimeLoggingOptions, RuntimeOperation, RuntimeOutcome, SafeCapture, TrackedLlmCall, captureException as captureServerException, captureMessage as captureServerMessage, createRuntimeLogger, emitLlmSelftestTrace, flushRuntimeLogs, installAutterAutoFlush, instrumentLlmClient, makeSafeCapture, redactAttributes, reportOutcome as reportServerOutcome, runtimeLogStats, runtimeLogger, trackLlmCall, withLlmCall, withProcessSpan, withRuntimeOperation } from '@autter/runtime-node';
+export { createAutterRelayRoute, registerAutter, withRuntimeRequest } from './server.js';
+export { AutoFlushHandle, AutoFlushOptions, AutterErrorHandlerOptions, AutterErrorResponseOptions, AutterLogging, AutterLoggingOptions, AutterRequestsOptions, AutterServer, AutterServerOptions, Breadcrumb, BreadcrumbInput, CODE_PATTERN, ClientErrorBody, ConsoleSinkOptions, FileSinkOptions, FlushTarget, InstrumentLlmOptions, LlmCallHandle, LlmCallInfo, LlmUsage, OtlpSinkOptions, RedactOptions, RelayOptions, RuntimeCarrier, RuntimeContextHandle, RuntimeEnrichContext, RuntimeEnrichEvent, RuntimeEnricher, RuntimeError, RuntimeErrorCatalog, RuntimeErrorDefinition, RuntimeErrorExtras, RuntimeErrorFactory, RuntimeErrorLike, RuntimeErrorOptions, RuntimeEvent, RuntimeLogContext, RuntimeLogContextValue, RuntimeLogLevel, RuntimeLoggingOptions, RuntimeOperation, RuntimeOperationKind, RuntimeOperationOptions, RuntimeOutcome, RuntimeRequestOptions, RuntimeSink, RuntimeSinkContext, SafeCapture, TrackedLlmCall, addBreadcrumb, autterErrorHandler, autterErrorResponse, autterFastify, autterFastifyErrors, autterKoa, autterRequests, captureRequestError, captureException as captureServerException, captureMessage as captureServerMessage, consoleSink, createRuntimeLogger, defineRuntimeErrors, emitLlmSelftestTrace, enrichDeployment, enrichEdgeGeo, enrichRequestSize, enrichUserAgent, errorAttributes, fileSink, flushRuntimeLogs, initAutterLogging, installAutterAutoFlush, instrumentLlmClient, isRuntimeErrorLike, makeSafeCapture, otlpSink, redactAttributes, redactText, reportOutcome as reportServerOutcome, runInBackground, runtimeContext, runtimeLogStats, runtimeLogger, toClientError, trackLlmCall, withLlmCall, withProcessSpan, withRuntimeOperation } from '@autter/runtime-node';

package/dist/index.js

@@ -1,40 +1,92 @@
 import {
+  CODE_PATTERN,
+  RuntimeError,
+  addBreadcrumb,
+  autterErrorHandler,
+  autterErrorResponse,
+  autterFastify,
+  autterFastifyErrors,
+  autterKoa,
+  autterRequests,
   captureException,
   captureMessage,
+  captureRequestError,
+  consoleSink,
   createAutterRelayRoute,
   createRuntimeLogger,
+  defineRuntimeErrors,
   emitLlmSelftestTrace,
+  enrichDeployment,
+  enrichEdgeGeo,
+  enrichRequestSize,
+  enrichUserAgent,
+  errorAttributes,
+  fileSink,
   flushRuntimeLogs,
+  initAutterLogging,
   installAutterAutoFlush,
   instrumentLlmClient,
+  isRuntimeErrorLike,
   makeSafeCapture,
+  otlpSink,
   redactAttributes,
+  redactText,
   registerAutter,
   reportOutcome,
+  runInBackground,
+  runtimeContext,
   runtimeLogStats,
   runtimeLogger,
+  toClientError,
   trackLlmCall,
   withLlmCall,
   withProcessSpan,
-  withRuntimeOperation
-} from "./chunk-NZPBSB6B.js";
+  withRuntimeOperation,
+  withRuntimeRequest
+} from "./chunk-QFEFRAVO.js";
 export {
+  CODE_PATTERN,
+  RuntimeError,
+  addBreadcrumb,
+  autterErrorHandler,
+  autterErrorResponse,
+  autterFastify,
+  autterFastifyErrors,
+  autterKoa,
+  autterRequests,
+  captureRequestError,
   captureException as captureServerException,
   captureMessage as captureServerMessage,
+  consoleSink,
   createAutterRelayRoute,
   createRuntimeLogger,
+  defineRuntimeErrors,
   emitLlmSelftestTrace,
+  enrichDeployment,
+  enrichEdgeGeo,
+  enrichRequestSize,
+  enrichUserAgent,
+  errorAttributes,
+  fileSink,
   flushRuntimeLogs,
+  initAutterLogging,
   installAutterAutoFlush,
   instrumentLlmClient,
+  isRuntimeErrorLike,
   makeSafeCapture,
+  otlpSink,
   redactAttributes,
+  redactText,
   registerAutter,
   reportOutcome as reportServerOutcome,
+  runInBackground,
+  runtimeContext,
   runtimeLogStats,
   runtimeLogger,
+  toClientError,
   trackLlmCall,
   withLlmCall,
   withProcessSpan,
-  withRuntimeOperation
+  withRuntimeOperation,
+  withRuntimeRequest
 };

package/dist/instrumentation-edge.cjs

@@ -0,0 +1,118 @@
+"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/instrumentation-edge.ts
+var instrumentation_edge_exports = {};
+__export(instrumentation_edge_exports, {
+  autterOnRequestError: () => autterOnRequestError,
+  onRequestError: () => onRequestError
+});
+module.exports = __toCommonJS(instrumentation_edge_exports);
+
+// src/request-error.ts
+var import_runtime_edge = require("@autter/runtime-edge");
+var CONTROL_FLOW_DIGEST = /^(?:NEXT_REDIRECT|NEXT_NOT_FOUND|NEXT_HTTP_ERROR_FALLBACK|DYNAMIC_SERVER_USAGE|BAILOUT_TO_CLIENT_SIDE_RENDERING)\b/;
+function digestOf(error) {
+  try {
+    const digest = error?.digest;
+    return typeof digest === "string" ? digest : "";
+  } catch {
+    return "";
+  }
+}
+function shouldReport(error, rule) {
+  if (rule === true) return true;
+  if (rule === false) return false;
+  if (typeof rule === "function") {
+    try {
+      return rule(error) === true;
+    } catch {
+      return false;
+    }
+  }
+  return !CONTROL_FLOW_DIGEST.test(digestOf(error));
+}
+function requestErrorAttributes(error, request, context) {
+  const out = {};
+  const put = (key, read, max) => {
+    try {
+      const value = read();
+      if (typeof value === "string" && value) out[key] = value.slice(0, max);
+    } catch {
+    }
+  };
+  put("next.route_path", () => context?.routePath, 500);
+  put("next.router_kind", () => context?.routerKind, 40);
+  put("next.route_type", () => context?.routeType, 40);
+  put("next.render_source", () => context?.renderSource, 80);
+  put("next.render_type", () => context?.renderType, 40);
+  put("next.revalidate_reason", () => context?.revalidateReason, 40);
+  put("next.digest", () => digestOf(error), 100);
+  put("http.request.method", () => {
+    const method = request?.method;
+    return typeof method === "string" ? method.toUpperCase() : void 0;
+  }, 16);
+  put("url.path", () => {
+    const path = request?.path;
+    return typeof path === "string" ? path.split(/[?#]/)[0] ?? "" : void 0;
+  }, 1e3);
+  return out;
+}
+var warnedNoEdgeOptions = false;
+function nextWaitUntil() {
+  try {
+    const store = globalThis[/* @__PURE__ */ Symbol.for("@next/request-context")];
+    const context = typeof store?.get === "function" ? store.get() : void 0;
+    const waitUntil = context?.waitUntil;
+    if (typeof waitUntil !== "function") return void 0;
+    return (promise) => waitUntil.call(context, promise);
+  } catch {
+    return void 0;
+  }
+}
+async function reportOnEdge(edge, error, attributes) {
+  const options = typeof edge === "function" ? edge() : edge;
+  if (!options) {
+    if (!warnedNoEdgeOptions) {
+      warnedNoEdgeOptions = true;
+      console.warn(
+        "[autter-runtime] onRequestError ran on the edge runtime without edge options; use autterOnRequestError({ edge: { apiKey, service } }) to report edge errors"
+      );
+    }
+    return;
+  }
+  const delivery = (0, import_runtime_edge.captureEdgeException)(options, error, attributes);
+  try {
+    nextWaitUntil()?.(delivery);
+  } catch {
+  }
+  await delivery;
+}
+
+// src/instrumentation-edge.ts
+function autterOnRequestError(options = {}) {
+  return async function onRequestError2(error, request, context) {
+    try {
+      if (!shouldReport(error, options.capture)) return;
+      await reportOnEdge(options.edge, error, requestErrorAttributes(error, request, context));
+    } catch {
+    }
+  };
+}
+var onRequestError = autterOnRequestError();

package/dist/instrumentation-edge.d.cts

@@ -0,0 +1,16 @@
+import { A as AutterOnRequestErrorOptions, N as NextOnRequestError } from './request-error-DzJdPaVe.cjs';
+export { a as NextRequestErrorContext, b as NextRequestErrorRequest } from './request-error-DzJdPaVe.cjs';
+import '@autter/runtime-edge';
+
+/**
+ * Edge build of `@autter/runtime-next/instrumentation`, picked by bundlers
+ * through the `edge-light` / `worker` export conditions (Next.js edge
+ * runtime). Same API as the default build, but it never references
+ * @autter/runtime-node or any Node module: errors are always sent over
+ * `/v1/logs` with the `edge` options.
+ */
+
+declare function autterOnRequestError(options?: AutterOnRequestErrorOptions): NextOnRequestError;
+declare const onRequestError: NextOnRequestError;
+
+export { AutterOnRequestErrorOptions, NextOnRequestError, autterOnRequestError, onRequestError };

package/dist/instrumentation-edge.d.ts

@@ -0,0 +1,16 @@
+import { A as AutterOnRequestErrorOptions, N as NextOnRequestError } from './request-error-DzJdPaVe.js';
+export { a as NextRequestErrorContext, b as NextRequestErrorRequest } from './request-error-DzJdPaVe.js';
+import '@autter/runtime-edge';
+
+/**
+ * Edge build of `@autter/runtime-next/instrumentation`, picked by bundlers
+ * through the `edge-light` / `worker` export conditions (Next.js edge
+ * runtime). Same API as the default build, but it never references
+ * @autter/runtime-node or any Node module: errors are always sent over
+ * `/v1/logs` with the `edge` options.
+ */
+
+declare function autterOnRequestError(options?: AutterOnRequestErrorOptions): NextOnRequestError;
+declare const onRequestError: NextOnRequestError;
+
+export { AutterOnRequestErrorOptions, NextOnRequestError, autterOnRequestError, onRequestError };

package/dist/instrumentation-edge.js

@@ -0,0 +1,21 @@
+import {
+  reportOnEdge,
+  requestErrorAttributes,
+  shouldReport
+} from "./chunk-CL2ENM4A.js";
+
+// src/instrumentation-edge.ts
+function autterOnRequestError(options = {}) {
+  return async function onRequestError2(error, request, context) {
+    try {
+      if (!shouldReport(error, options.capture)) return;
+      await reportOnEdge(options.edge, error, requestErrorAttributes(error, request, context));
+    } catch {
+    }
+  };
+}
+var onRequestError = autterOnRequestError();
+export {
+  autterOnRequestError,
+  onRequestError
+};

package/dist/instrumentation.cjs

@@ -0,0 +1,138 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/instrumentation.ts
+var instrumentation_exports = {};
+__export(instrumentation_exports, {
+  autterOnRequestError: () => autterOnRequestError,
+  onRequestError: () => onRequestError
+});
+module.exports = __toCommonJS(instrumentation_exports);
+
+// src/request-error.ts
+var import_runtime_edge = require("@autter/runtime-edge");
+var CONTROL_FLOW_DIGEST = /^(?:NEXT_REDIRECT|NEXT_NOT_FOUND|NEXT_HTTP_ERROR_FALLBACK|DYNAMIC_SERVER_USAGE|BAILOUT_TO_CLIENT_SIDE_RENDERING)\b/;
+function digestOf(error) {
+  try {
+    const digest = error?.digest;
+    return typeof digest === "string" ? digest : "";
+  } catch {
+    return "";
+  }
+}
+function shouldReport(error, rule) {
+  if (rule === true) return true;
+  if (rule === false) return false;
+  if (typeof rule === "function") {
+    try {
+      return rule(error) === true;
+    } catch {
+      return false;
+    }
+  }
+  return !CONTROL_FLOW_DIGEST.test(digestOf(error));
+}
+function requestErrorAttributes(error, request, context) {
+  const out = {};
+  const put = (key, read, max) => {
+    try {
+      const value = read();
+      if (typeof value === "string" && value) out[key] = value.slice(0, max);
+    } catch {
+    }
+  };
+  put("next.route_path", () => context?.routePath, 500);
+  put("next.router_kind", () => context?.routerKind, 40);
+  put("next.route_type", () => context?.routeType, 40);
+  put("next.render_source", () => context?.renderSource, 80);
+  put("next.render_type", () => context?.renderType, 40);
+  put("next.revalidate_reason", () => context?.revalidateReason, 40);
+  put("next.digest", () => digestOf(error), 100);
+  put("http.request.method", () => {
+    const method = request?.method;
+    return typeof method === "string" ? method.toUpperCase() : void 0;
+  }, 16);
+  put("url.path", () => {
+    const path = request?.path;
+    return typeof path === "string" ? path.split(/[?#]/)[0] ?? "" : void 0;
+  }, 1e3);
+  return out;
+}
+var warnedNoEdgeOptions = false;
+function nextWaitUntil() {
+  try {
+    const store = globalThis[/* @__PURE__ */ Symbol.for("@next/request-context")];
+    const context = typeof store?.get === "function" ? store.get() : void 0;
+    const waitUntil = context?.waitUntil;
+    if (typeof waitUntil !== "function") return void 0;
+    return (promise) => waitUntil.call(context, promise);
+  } catch {
+    return void 0;
+  }
+}
+async function reportOnEdge(edge, error, attributes) {
+  const options = typeof edge === "function" ? edge() : edge;
+  if (!options) {
+    if (!warnedNoEdgeOptions) {
+      warnedNoEdgeOptions = true;
+      console.warn(
+        "[autter-runtime] onRequestError ran on the edge runtime without edge options; use autterOnRequestError({ edge: { apiKey, service } }) to report edge errors"
+      );
+    }
+    return;
+  }
+  const delivery = (0, import_runtime_edge.captureEdgeException)(options, error, attributes);
+  try {
+    nextWaitUntil()?.(delivery);
+  } catch {
+  }
+  await delivery;
+}
+
+// src/instrumentation.ts
+function autterOnRequestError(options = {}) {
+  return async function onRequestError2(error, request, context) {
+    try {
+      if (!shouldReport(error, options.capture)) return;
+      const attributes = requestErrorAttributes(error, request, context);
+      if (typeof process === "undefined") {
+        await reportOnEdge(options.edge, error, attributes);
+        return;
+      }
+      if (process.env.NEXT_RUNTIME === "edge") {
+        await reportOnEdge(options.edge, error, attributes);
+      } else {
+        const node = await Promise.resolve().then(() => __toESM(require("@autter/runtime-node"), 1));
+        (node.captureRequestError ?? node.captureException)(error, attributes);
+      }
+    } catch {
+    }
+  };
+}
+var onRequestError = autterOnRequestError();