@autter/runtime-next 1.5.0 → 1.6.1

package/README.md

@@ -9,7 +9,8 @@ same-origin relay route, and a React error boundary.
 npm install @autter/runtime-next
 ```
 
-Set `AUTTER_RUNTIME_KEY` in your environment. Then three small files.
+Set `AUTTER_RUNTIME_KEY` in your environment. Then three small files, and
+(recommended) one line of `next.config`.
 
 The package has two entry points — this split is what keeps the Node
 OpenTelemetry SDK out of your browser bundle:
@@ -18,10 +19,37 @@ OpenTelemetry SDK out of your browser bundle:
   `instrumentation.ts`, route handlers, server components.
 - `@autter/runtime-next/client` — client components: browser tracker +
   error boundary. Never imports Node code.
+- `@autter/runtime-next/instrumentation` — `onRequestError` for
+  `instrumentation.ts`; safe on both the Node and edge runtimes.
+
+**`next.config`** (recommended) — load the Node SDK from `node_modules`
+instead of bundling it:
+
+```js
+// next.config.mjs
+export default {
+  serverExternalPackages: ["@autter/runtime-node"],
+};
+```
+
+Next bundles server dependencies separately into `instrumentation.ts` and
+into the route bundles. Since 1.6.1 every copy shares the SDK
+`registerAutter` started, so routes, server components and server actions
+(`withRuntimeRequest`, `captureServerException`, `runtimeLogger`,
+`runtimeContext`, …) export through it, and an error `withRuntimeRequest`
+reported is not reported again by `onRequestError`, with or without this
+line. The line keeps the SDK and its OpenTelemetry
+dependencies out of the route bundles: in our Next 15.5 and 16.4 test app
+the server output had 1.1 to 2.3 MB less JavaScript. (1.6.0 needed it:
+without it, request summaries went to the console and errors were reported
+twice.) Next 14.2:
+`experimental: { serverComponentsExternalPackages: ["@autter/runtime-node"] }`.
 
 **1. `instrumentation.ts`** — server tracing/errors:
 
 ```ts
+import { autterOnRequestError } from "@autter/runtime-next/instrumentation";
+
 export async function register() {
   if (process.env.NEXT_RUNTIME === "nodejs") {
     const { registerAutter } = await import("@autter/runtime-next");
@@ -33,8 +61,49 @@ export async function register() {
     });
   }
 }
+
+// Next 15+: errors Next catches in server components, server actions, route
+// handlers and middleware, with their stack (otherwise: stackless 500s).
+export const onRequestError = autterOnRequestError({
+  // Edge runtime only (middleware, edge routes): no tracker runs there, so
+  // errors go straight to /v1/logs with these options.
+  edge: { apiKey: process.env.AUTTER_RUNTIME_KEY, service: "web-app" },
+});
 ```
 
+`@autter/runtime-next/instrumentation` is safe to import at the top of
+`instrumentation.ts`, which Next compiles for both runtimes: on the edge,
+bundlers resolve it (through the `edge-light`/`worker` export conditions) to a
+build with no Node imports, and the Node build loads `@autter/runtime-node`
+only inside a `process.env.NEXT_RUNTIME` branch Next removes from edge
+bundles. Without edge errors to report, `export { onRequestError } from
+"@autter/runtime-next/instrumentation"` is enough.
+
+On Node the error is recorded on the request span through the
+`registerAutter` tracker — once, even when `withRuntimeRequest` already
+reported it (Next's context is then added to that report). Recorded with
+it: `next.route_path` (the route template: `/blog/[slug]`, `/api/orders`;
+middleware is `/middleware` on Next 15 and `/proxy` on Next 16),
+`next.router_kind`, `next.route_type` (`render`, `route`, `action`,
+`middleware` on Next 15, `proxy` on Next 16), `next.render_source`
+(`react-server-components`, `react-server-components-payload`,
+`server-rendering`), `next.render_type`, `next.revalidate_reason`,
+`next.digest` (matches the `digest` your error boundary sees),
+`http.request.method` and `url.path` without its query string. Headers and
+cookies are never read. Next's control-flow signals (`redirect()`,
+`notFound()`, `forbidden()`, `unauthorized()`, dynamic bailouts) are
+skipped; `capture: true` or a predicate changes that.
+
+On the edge runtime, Next calls `onRequestError` inside the function for
+middleware and edge pages; the record goes out with the `edge` options and
+is also handed to the request's `waitUntil`, since Next does not await the
+hook for errors raised while rendering. Edge route handlers
+(`export const runtime = "edge"` in `route.ts`) are the exception: Next
+never calls the hook inside them. Self-hosted (`next start`), the Node
+server reports them instead, so the Node tracker records them with their
+own stack, `next.router_kind` `Pages Router` and `next.route_path` such as
+`/api/orders/route`.
+
 `registerAutter` passes options straight to `initAutterServer`, so the
 server SDK's defaults apply out of the box: exporters are flushed on
 process exit (`autoFlush`) and custom attributes are scrubbed for PII
@@ -76,12 +145,32 @@ export function Providers({ children }: { children: React.ReactNode }) {
 React render errors don't reach `window.onerror` — the boundary reports
 them via `captureException` and then renders your fallback.
 
+**Linking browser errors to server traces** (opt-in): call
+`enableTracePropagation` from `@autter/runtime-next/client`, next to
+`initAutterBrowser` and before the app sends requests. Same-origin `fetch`
+and XHR requests (your route handlers and server actions) then carry a W3C
+`traceparent`, which `registerAutter` continues, so a browser error links to
+the server trace of the request behind it. Cross-origin APIs get one only
+when listed in `tracePropagationTargets`, and must allow the header in CORS.
+`disableTracePropagation()` turns it off; the rules are in
+`@autter/runtime-browser`'s README ("Trace propagation").
+
+```tsx
+"use client";
+import { initAutterBrowser, enableTracePropagation } from "@autter/runtime-next/client";
+
+initAutterBrowser({ endpoint: "/api/autter-runtime", service: "web-app" });
+enableTracePropagation({ tracePropagationTargets: ["https://api.example.com/"] });
+```
+
 Also re-exported for convenience: `captureException`, `captureMessage`,
 `trackEvent`, `setUser`, `setContext`, `flush` (from
 `@autter/runtime-next/client`) and `captureServerException`,
 `captureServerMessage`, `withProcessSpan`, `withLlmCall`, `trackLlmCall`,
 `instrumentLlmClient`, `emitLlmSelftestTrace` (from the root /
-`@autter/runtime-next/server`).
+`@autter/runtime-next/server`), plus the server error hooks for custom
+servers: `autterErrorHandler`, `autterFastifyErrors`, `autterKoa` and
+`captureRequestError`.
 
 > Importing the root entry from a client component pulls the Node OTel SDK
 > into the browser bundle and fails the build (`fs` cannot be resolved).

package/dist/chunk-CL2ENM4A.js

@@ -0,0 +1,85 @@
+// src/request-error.ts
+import { captureEdgeException } from "@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 = captureEdgeException(options, error, attributes);
+  try {
+    nextWaitUntil()?.(delivery);
+  } catch {
+  }
+  await delivery;
+}
+
+export {
+  shouldReport,
+  requestErrorAttributes,
+  reportOnEdge
+};

package/dist/{chunk-CXHBXTTB.js → chunk-HLKKX6FY.js}

@@ -8,7 +8,7 @@ import {
 // package.json
 var package_default = {
   name: "@autter/runtime-next",
-  version: "1.5.0",
+  version: "1.6.1",
   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",
@@ -35,6 +35,19 @@ var package_default = {
       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: [
@@ -50,9 +63,9 @@ var package_default = {
     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.4.0",
-    "@autter/runtime-edge": "^1.0.0",
-    "@autter/runtime-node": "^1.5.0"
+    "@autter/runtime-browser": "^1.6.0",
+    "@autter/runtime-edge": "^1.1.0",
+    "@autter/runtime-node": "^1.6.1"
   },
   peerDependencies: {
     react: ">=18"
@@ -104,6 +117,10 @@ import {
   autterRequests,
   autterFastify,
   autterErrorResponse,
+  autterErrorHandler,
+  autterFastifyErrors,
+  autterKoa,
+  captureRequestError,
   RuntimeError,
   defineRuntimeErrors,
   isRuntimeErrorLike,
@@ -118,7 +135,8 @@ import {
   otlpSink,
   consoleSink,
   fileSink,
-  redactText
+  redactText,
+  addBreadcrumb
 } from "@autter/runtime-node";
 function registerAutter(options) {
   return initAutterServer({
@@ -186,6 +204,10 @@ export {
   autterRequests,
   autterFastify,
   autterErrorResponse,
+  autterErrorHandler,
+  autterFastifyErrors,
+  autterKoa,
+  captureRequestError,
   RuntimeError,
   defineRuntimeErrors,
   isRuntimeErrorLike,
@@ -200,5 +222,6 @@ export {
   otlpSink,
   consoleSink,
   fileSink,
-  redactText
+  redactText,
+  addBreadcrumb
 };

package/dist/client.cjs

@@ -34,10 +34,15 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 var client_exports = {};
 __export(client_exports, {
   AutterErrorBoundary: () => AutterErrorBoundary,
+  addBreadcrumb: () => import_breadcrumbs.addBreadcrumb,
   autterErrorFromResponse: () => import_runtime_browser2.autterErrorFromResponse,
   captureException: () => import_runtime_browser2.captureException,
   captureMessage: () => import_runtime_browser2.captureMessage,
   captureOutcome: () => import_runtime_browser2.captureOutcome,
+  clearBreadcrumbs: () => import_breadcrumbs.clearBreadcrumbs,
+  disableTracePropagation: () => import_tracing.disableTracePropagation,
+  enableBreadcrumbs: () => import_breadcrumbs.enableBreadcrumbs,
+  enableTracePropagation: () => import_tracing.enableTracePropagation,
   flush: () => import_runtime_browser2.flush,
   initAutterBrowser: () => import_runtime_browser2.initAutterBrowser,
   setContext: () => import_runtime_browser2.setContext,
@@ -46,6 +51,8 @@ __export(client_exports, {
 });
 module.exports = __toCommonJS(client_exports);
 var import_runtime_browser2 = require("@autter/runtime-browser");
+var import_breadcrumbs = require("@autter/runtime-browser/breadcrumbs");
+var import_tracing = require("@autter/runtime-browser/tracing");
 
 // src/error-boundary.ts
 var React = __toESM(require("react"), 1);
@@ -77,10 +84,15 @@ var AutterErrorBoundary = class extends React.Component {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AutterErrorBoundary,
+  addBreadcrumb,
   autterErrorFromResponse,
   captureException,
   captureMessage,
   captureOutcome,
+  clearBreadcrumbs,
+  disableTracePropagation,
+  enableBreadcrumbs,
+  enableTracePropagation,
   flush,
   initAutterBrowser,
   setContext,

package/dist/client.d.cts

@@ -1,4 +1,6 @@
 export { AutterSeverity, autterErrorFromResponse, captureException, captureMessage, captureOutcome, flush, initAutterBrowser, setContext, setUser, trackEvent } from '@autter/runtime-browser';
+export { Breadcrumb, BreadcrumbInput, BreadcrumbOptions, addBreadcrumb, clearBreadcrumbs, enableBreadcrumbs } from '@autter/runtime-browser/breadcrumbs';
+export { TracePropagationOptions, disableTracePropagation, enableTracePropagation } from '@autter/runtime-browser/tracing';
 import * as React from 'react';
 
 /**

package/dist/client.d.ts

@@ -1,4 +1,6 @@
 export { AutterSeverity, autterErrorFromResponse, captureException, captureMessage, captureOutcome, flush, initAutterBrowser, setContext, setUser, trackEvent } from '@autter/runtime-browser';
+export { Breadcrumb, BreadcrumbInput, BreadcrumbOptions, addBreadcrumb, clearBreadcrumbs, enableBreadcrumbs } from '@autter/runtime-browser/breadcrumbs';
+export { TracePropagationOptions, disableTracePropagation, enableTracePropagation } from '@autter/runtime-browser/tracing';
 import * as React from 'react';
 
 /**

package/dist/client.js

@@ -15,6 +15,15 @@ import {
   flush,
   autterErrorFromResponse
 } from "@autter/runtime-browser";
+import {
+  enableBreadcrumbs,
+  addBreadcrumb,
+  clearBreadcrumbs
+} from "@autter/runtime-browser/breadcrumbs";
+import {
+  enableTracePropagation,
+  disableTracePropagation
+} from "@autter/runtime-browser/tracing";
 
 // src/error-boundary.ts
 import * as React from "react";
@@ -45,10 +54,15 @@ var AutterErrorBoundary = class extends React.Component {
 };
 export {
   AutterErrorBoundary,
+  addBreadcrumb,
   autterErrorFromResponse,
   captureException2 as captureException,
   captureMessage,
   captureOutcome,
+  clearBreadcrumbs,
+  disableTracePropagation,
+  enableBreadcrumbs,
+  enableTracePropagation,
   flush,
   initAutterBrowser,
   setContext,

package/dist/index.cjs

@@ -22,9 +22,14 @@ 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,
@@ -68,7 +73,7 @@ var import_runtime_node = require("@autter/runtime-node");
 // package.json
 var package_default = {
   name: "@autter/runtime-next",
-  version: "1.5.0",
+  version: "1.6.1",
   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",
@@ -95,6 +100,19 @@ var package_default = {
       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: [
@@ -110,9 +128,9 @@ var package_default = {
     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.4.0",
-    "@autter/runtime-edge": "^1.0.0",
-    "@autter/runtime-node": "^1.5.0"
+    "@autter/runtime-browser": "^1.6.0",
+    "@autter/runtime-edge": "^1.1.0",
+    "@autter/runtime-node": "^1.6.1"
   },
   peerDependencies: {
     react: ">=18"
@@ -187,9 +205,14 @@ function withRuntimeRequest(handler, options = {}) {
 0 && (module.exports = {
   CODE_PATTERN,
   RuntimeError,
+  addBreadcrumb,
+  autterErrorHandler,
   autterErrorResponse,
   autterFastify,
+  autterFastifyErrors,
+  autterKoa,
   autterRequests,
+  captureRequestError,
   captureServerException,
   captureServerMessage,
   consoleSink,

package/dist/index.d.cts

@@ -1,2 +1,2 @@
 export { createAutterRelayRoute, registerAutter, withRuntimeRequest } from './server.cjs';
-export { AutoFlushHandle, AutoFlushOptions, AutterErrorResponseOptions, AutterLogging, AutterLoggingOptions, AutterRequestsOptions, AutterServer, AutterServerOptions, 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, autterErrorResponse, autterFastify, autterRequests, 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';
+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, withRuntimeRequest } from './server.js';
-export { AutoFlushHandle, AutoFlushOptions, AutterErrorResponseOptions, AutterLogging, AutterLoggingOptions, AutterRequestsOptions, AutterServer, AutterServerOptions, 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, autterErrorResponse, autterFastify, autterRequests, 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';
+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,11 +1,16 @@
 import {
   CODE_PATTERN,
   RuntimeError,
+  addBreadcrumb,
+  autterErrorHandler,
   autterErrorResponse,
   autterFastify,
+  autterFastifyErrors,
+  autterKoa,
   autterRequests,
   captureException,
   captureMessage,
+  captureRequestError,
   consoleSink,
   createAutterRelayRoute,
   createRuntimeLogger,
@@ -38,13 +43,18 @@ import {
   withProcessSpan,
   withRuntimeOperation,
   withRuntimeRequest
-} from "./chunk-CXHBXTTB.js";
+} from "./chunk-HLKKX6FY.js";
 export {
   CODE_PATTERN,
   RuntimeError,
+  addBreadcrumb,
+  autterErrorHandler,
   autterErrorResponse,
   autterFastify,
+  autterFastifyErrors,
+  autterKoa,
   autterRequests,
+  captureRequestError,
   captureException as captureServerException,
   captureMessage as captureServerMessage,
   consoleSink,

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();

package/dist/instrumentation.d.cts

@@ -0,0 +1,39 @@
+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';
+
+/**
+ * `@autter/runtime-next/instrumentation` — Next.js `onRequestError` (Next 15+).
+ * Errors Next catches in server components, server actions, route handlers
+ * and middleware are reported with their stack and Next's context, instead
+ * of arriving as stackless 500s:
+ *
+ *   // instrumentation.ts
+ *   export { onRequestError } from "@autter/runtime-next/instrumentation";
+ *
+ * Safe for both runtimes Next compiles `instrumentation.ts` for:
+ *
+ * - Node: records the error on the request's span through the tracker that
+ *   `registerAutter` started (`captureRequestError`). @autter/runtime-node is
+ *   imported lazily, inside a `process.env.NEXT_RUNTIME` branch Next removes
+ *   from edge bundles.
+ * - Edge: the package's `edge-light`/`worker` export condition resolves to an
+ *   edge-only build that never references Node code; errors go to `/v1/logs`
+ *   with the `edge` options (see `autterOnRequestError`).
+ */
+
+/**
+ * Build an `onRequestError` with options:
+ *
+ *   export const onRequestError = autterOnRequestError({
+ *     edge: { apiKey: process.env.AUTTER_RUNTIME_KEY, service: "web-app" },
+ *   });
+ *
+ * Never throws into Next.
+ */
+declare function autterOnRequestError(options?: AutterOnRequestErrorOptions): NextOnRequestError;
+/** Ready-made `onRequestError`: Node errors go to the `registerAutter`
+ * tracker; on the edge it needs `autterOnRequestError({ edge })`. */
+declare const onRequestError: NextOnRequestError;
+
+export { AutterOnRequestErrorOptions, NextOnRequestError, autterOnRequestError, onRequestError };

package/dist/instrumentation.d.ts

@@ -0,0 +1,39 @@
+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';
+
+/**
+ * `@autter/runtime-next/instrumentation` — Next.js `onRequestError` (Next 15+).
+ * Errors Next catches in server components, server actions, route handlers
+ * and middleware are reported with their stack and Next's context, instead
+ * of arriving as stackless 500s:
+ *
+ *   // instrumentation.ts
+ *   export { onRequestError } from "@autter/runtime-next/instrumentation";
+ *
+ * Safe for both runtimes Next compiles `instrumentation.ts` for:
+ *
+ * - Node: records the error on the request's span through the tracker that
+ *   `registerAutter` started (`captureRequestError`). @autter/runtime-node is
+ *   imported lazily, inside a `process.env.NEXT_RUNTIME` branch Next removes
+ *   from edge bundles.
+ * - Edge: the package's `edge-light`/`worker` export condition resolves to an
+ *   edge-only build that never references Node code; errors go to `/v1/logs`
+ *   with the `edge` options (see `autterOnRequestError`).
+ */
+
+/**
+ * Build an `onRequestError` with options:
+ *
+ *   export const onRequestError = autterOnRequestError({
+ *     edge: { apiKey: process.env.AUTTER_RUNTIME_KEY, service: "web-app" },
+ *   });
+ *
+ * Never throws into Next.
+ */
+declare function autterOnRequestError(options?: AutterOnRequestErrorOptions): NextOnRequestError;
+/** Ready-made `onRequestError`: Node errors go to the `registerAutter`
+ * tracker; on the edge it needs `autterOnRequestError({ edge })`. */
+declare const onRequestError: NextOnRequestError;
+
+export { AutterOnRequestErrorOptions, NextOnRequestError, autterOnRequestError, onRequestError };

package/dist/instrumentation.js

@@ -0,0 +1,31 @@
+import {
+  reportOnEdge,
+  requestErrorAttributes,
+  shouldReport
+} from "./chunk-CL2ENM4A.js";
+
+// 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 import("@autter/runtime-node");
+        (node.captureRequestError ?? node.captureException)(error, attributes);
+      }
+    } catch {
+    }
+  };
+}
+var onRequestError = autterOnRequestError();
+export {
+  autterOnRequestError,
+  onRequestError
+};

package/dist/request-error-DzJdPaVe.d.cts

@@ -0,0 +1,55 @@
+import { AutterEdgeOptions } from '@autter/runtime-edge';
+
+/**
+ * Shared, runtime-neutral half of Next.js `onRequestError` support. Imports
+ * only @autter/runtime-edge (no Node modules), so it is safe in the edge
+ * bundle; the Node half lives behind a dynamic import in instrumentation.ts.
+ */
+
+/** Next.js `onRequestError` request argument (typed structurally; no `next` dependency). */
+interface NextRequestErrorRequest {
+    /** Resource path, e.g. `/blog?name=foo` — recorded without the query string. */
+    path?: string;
+    method?: string;
+    /** Never read: cookies and auth headers stay out of telemetry. */
+    headers?: unknown;
+}
+/** Next.js `onRequestError` context argument. */
+interface NextRequestErrorContext {
+    /** `"App Router"` or `"Pages Router"` (also what Next passes for middleware and edge route handlers). */
+    routerKind?: string;
+    /**
+     * The route template, e.g. `/blog/[slug]` or `/api/orders`. Middleware:
+     * `/middleware` (Next 15) or `/proxy` (Next 16). An edge route handler
+     * reported by `next start`: the page, e.g. `/api/orders/route`.
+     */
+    routePath?: string;
+    /** `"render"`, `"route"`, `"action"`, `"middleware"` (Next 15) or `"proxy"` (Next 16). */
+    routeType?: string;
+    /** `"react-server-components"`, `"react-server-components-payload"` or `"server-rendering"`. */
+    renderSource?: string;
+    /** `"on-demand"`, `"stale"` or undefined (a normal request). */
+    revalidateReason?: string;
+    /** `"dynamic"` or `"dynamic-resume"` (PPR). */
+    renderType?: string;
+}
+/** The function Next.js calls from `instrumentation.ts`. */
+type NextOnRequestError = (error: unknown, request: NextRequestErrorRequest, context: NextRequestErrorContext) => Promise<void>;
+interface AutterOnRequestErrorOptions {
+    /**
+     * Which errors to report. Default: every error except Next's control-flow
+     * signals (`redirect()`, `notFound()`, `forbidden()`, `unauthorized()`,
+     * dynamic-rendering bailouts). `true` reports everything; a predicate
+     * decides per error.
+     */
+    capture?: boolean | ((error: unknown) => boolean);
+    /**
+     * Edge runtime only (middleware, `export const runtime = "edge"`): the
+     * Node tracker does not run there, so errors are sent straight to the
+     * ingester's `/v1/logs` with these options — a SERVER key. A function is
+     * called per error. Without it, edge errors are skipped (one warning).
+     */
+    edge?: AutterEdgeOptions | (() => AutterEdgeOptions | undefined);
+}
+
+export type { AutterOnRequestErrorOptions as A, NextOnRequestError as N, NextRequestErrorContext as a, NextRequestErrorRequest as b };

package/dist/request-error-DzJdPaVe.d.ts

@@ -0,0 +1,55 @@
+import { AutterEdgeOptions } from '@autter/runtime-edge';
+
+/**
+ * Shared, runtime-neutral half of Next.js `onRequestError` support. Imports
+ * only @autter/runtime-edge (no Node modules), so it is safe in the edge
+ * bundle; the Node half lives behind a dynamic import in instrumentation.ts.
+ */
+
+/** Next.js `onRequestError` request argument (typed structurally; no `next` dependency). */
+interface NextRequestErrorRequest {
+    /** Resource path, e.g. `/blog?name=foo` — recorded without the query string. */
+    path?: string;
+    method?: string;
+    /** Never read: cookies and auth headers stay out of telemetry. */
+    headers?: unknown;
+}
+/** Next.js `onRequestError` context argument. */
+interface NextRequestErrorContext {
+    /** `"App Router"` or `"Pages Router"` (also what Next passes for middleware and edge route handlers). */
+    routerKind?: string;
+    /**
+     * The route template, e.g. `/blog/[slug]` or `/api/orders`. Middleware:
+     * `/middleware` (Next 15) or `/proxy` (Next 16). An edge route handler
+     * reported by `next start`: the page, e.g. `/api/orders/route`.
+     */
+    routePath?: string;
+    /** `"render"`, `"route"`, `"action"`, `"middleware"` (Next 15) or `"proxy"` (Next 16). */
+    routeType?: string;
+    /** `"react-server-components"`, `"react-server-components-payload"` or `"server-rendering"`. */
+    renderSource?: string;
+    /** `"on-demand"`, `"stale"` or undefined (a normal request). */
+    revalidateReason?: string;
+    /** `"dynamic"` or `"dynamic-resume"` (PPR). */
+    renderType?: string;
+}
+/** The function Next.js calls from `instrumentation.ts`. */
+type NextOnRequestError = (error: unknown, request: NextRequestErrorRequest, context: NextRequestErrorContext) => Promise<void>;
+interface AutterOnRequestErrorOptions {
+    /**
+     * Which errors to report. Default: every error except Next's control-flow
+     * signals (`redirect()`, `notFound()`, `forbidden()`, `unauthorized()`,
+     * dynamic-rendering bailouts). `true` reports everything; a predicate
+     * decides per error.
+     */
+    capture?: boolean | ((error: unknown) => boolean);
+    /**
+     * Edge runtime only (middleware, `export const runtime = "edge"`): the
+     * Node tracker does not run there, so errors are sent straight to the
+     * ingester's `/v1/logs` with these options — a SERVER key. A function is
+     * called per error. Without it, edge errors are skipped (one warning).
+     */
+    edge?: AutterEdgeOptions | (() => AutterEdgeOptions | undefined);
+}
+
+export type { AutterOnRequestErrorOptions as A, NextOnRequestError as N, NextRequestErrorContext as a, NextRequestErrorRequest as b };

package/dist/server.cjs

@@ -22,9 +22,14 @@ var server_exports = {};
 __export(server_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,
@@ -66,7 +71,7 @@ var import_runtime_node = require("@autter/runtime-node");
 // package.json
 var package_default = {
   name: "@autter/runtime-next",
-  version: "1.5.0",
+  version: "1.6.1",
   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",
@@ -93,6 +98,19 @@ var package_default = {
       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: [
@@ -108,9 +126,9 @@ var package_default = {
     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.4.0",
-    "@autter/runtime-edge": "^1.0.0",
-    "@autter/runtime-node": "^1.5.0"
+    "@autter/runtime-browser": "^1.6.0",
+    "@autter/runtime-edge": "^1.1.0",
+    "@autter/runtime-node": "^1.6.1"
   },
   peerDependencies: {
     react: ">=18"
@@ -185,9 +203,14 @@ function withRuntimeRequest(handler, options = {}) {
 0 && (module.exports = {
   CODE_PATTERN,
   RuntimeError,
+  addBreadcrumb,
+  autterErrorHandler,
   autterErrorResponse,
   autterFastify,
+  autterFastifyErrors,
+  autterKoa,
   autterRequests,
+  captureRequestError,
   captureServerException,
   captureServerMessage,
   consoleSink,

package/dist/server.d.cts

@@ -1,5 +1,5 @@
 import { RelayOptions, AutterServerOptions, AutterServer, RuntimeRequestOptions } from '@autter/runtime-node';
-export { AutoFlushHandle, AutoFlushOptions, AutterErrorResponseOptions, AutterLogging, AutterLoggingOptions, AutterRequestsOptions, AutterServer, AutterServerOptions, 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, autterErrorResponse, autterFastify, autterRequests, 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';
+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';
 
 /**
  * Server half of @autter/runtime-next. Safe to import anywhere Node runs:

package/dist/server.d.ts

@@ -1,5 +1,5 @@
 import { RelayOptions, AutterServerOptions, AutterServer, RuntimeRequestOptions } from '@autter/runtime-node';
-export { AutoFlushHandle, AutoFlushOptions, AutterErrorResponseOptions, AutterLogging, AutterLoggingOptions, AutterRequestsOptions, AutterServer, AutterServerOptions, 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, autterErrorResponse, autterFastify, autterRequests, 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';
+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';
 
 /**
  * Server half of @autter/runtime-next. Safe to import anywhere Node runs:

package/dist/server.js

@@ -1,11 +1,16 @@
 import {
   CODE_PATTERN,
   RuntimeError,
+  addBreadcrumb,
+  autterErrorHandler,
   autterErrorResponse,
   autterFastify,
+  autterFastifyErrors,
+  autterKoa,
   autterRequests,
   captureException,
   captureMessage,
+  captureRequestError,
   consoleSink,
   createAutterRelayRoute,
   createRuntimeLogger,
@@ -38,13 +43,18 @@ import {
   withProcessSpan,
   withRuntimeOperation,
   withRuntimeRequest
-} from "./chunk-CXHBXTTB.js";
+} from "./chunk-HLKKX6FY.js";
 export {
   CODE_PATTERN,
   RuntimeError,
+  addBreadcrumb,
+  autterErrorHandler,
   autterErrorResponse,
   autterFastify,
+  autterFastifyErrors,
+  autterKoa,
   autterRequests,
+  captureRequestError,
   captureException as captureServerException,
   captureMessage as captureServerMessage,
   consoleSink,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@autter/runtime-next",
-	"version": "1.5.0",
+	"version": "1.6.1",
 	"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",
@@ -27,6 +27,19 @@
 			"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": [
@@ -42,9 +55,9 @@
 		"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.4.0",
-		"@autter/runtime-edge": "^1.0.0",
-		"@autter/runtime-node": "^1.5.0"
+		"@autter/runtime-browser": "^1.6.0",
+		"@autter/runtime-edge": "^1.1.0",
+		"@autter/runtime-node": "^1.6.1"
 	},
 	"peerDependencies": {
 		"react": ">=18"