@oluso/nextjs 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 David Ezeh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,178 @@
+# @oluso/nextjs
+
+AI-powered error monitoring for Next.js applications: server-side capture for the App Router, Pages Router, and Middleware, plus React bindings for Client Components. Works unchanged on both the Node.js and Edge runtimes.
+
+## Installation
+
+```bash
+npm install @oluso/nextjs
+```
+
+Requires Next.js `>=13.4.0` and React `>=18.2.0`.
+
+## Recommended setup: `instrumentation.ts`
+
+Next.js's [`instrumentation.ts`](https://nextjs.org/docs/app/building-your-application/optimizing/instrumentation) is the one place guaranteed to run exactly once per server instance, and its `onRequestError` hook is called for errors from Server Components, Route Handlers, Server Actions, and Middleware — whether or not you've wrapped them individually. This is the fastest path to full coverage:
+
+```ts
+// instrumentation.ts
+import { Oluso, registerOlusoProcessHandlers, createOnRequestError } from '@oluso/nextjs';
+
+export const oluso = new Oluso({
+  apiKey: process.env.OLUSO_API_KEY!,
+  environment: process.env.NODE_ENV,
+});
+
+export async function register() {
+  registerOlusoProcessHandlers(oluso); // uncaughtException / unhandledRejection, Node runtime only
+}
+
+export const onRequestError = createOnRequestError(oluso);
+```
+
+That's the whole server-side integration for a basic setup. The `with*` wrappers below are opt-in, for routes where you also want request-scoped breadcrumbs recorded *during* the handler, not just the failure itself.
+
+## App Router route handlers
+
+```ts
+// app/api/widgets/route.ts
+import { withOluso } from '@oluso/nextjs';
+import { oluso } from '../../../instrumentation';
+
+export const GET = withOluso(oluso, async (req) => {
+  oluso.addBreadcrumb({ message: 'fetching widgets', category: 'db' });
+  const widgets = await db.widgets.findMany();
+  return Response.json(widgets);
+});
+```
+
+Wrap each exported method (`GET`, `POST`, ...) separately. Thrown errors and 5xx responses are reported with the request's method, URL, and sanitized headers attached; the request body is never read here (it's a stream your handler needs to consume itself).
+
+## Pages Router API routes
+
+```ts
+// pages/api/widgets.ts
+import { withOlusoApiRoute } from '@oluso/nextjs';
+import { oluso } from '../../instrumentation';
+
+export default withOlusoApiRoute(oluso, async (req, res) => {
+  const widgets = await db.widgets.findMany();
+  res.json(widgets);
+});
+```
+
+## Middleware
+
+```ts
+// middleware.ts
+import { withOlusoMiddleware } from '@oluso/nextjs';
+import { oluso } from './instrumentation';
+
+export const middleware = withOlusoMiddleware(oluso, async (req) => {
+  ...
+});
+```
+
+Middleware always runs on the Edge runtime — this wrapper (and the rest of the server client) has no dependency on Node's `http`/`os` modules, so it works there unchanged.
+
+## Client Components
+
+Import from the `/client` subpath, which carries its own `'use client'` directive — importing these from the main entry point would pull server-only code into the client bundle.
+
+```tsx
+// app/layout.tsx
+import { OlusoProvider } from '@oluso/nextjs/client';
+
+export default function RootLayout({ children }: { children: React.ReactNode }) {
+  return (
+    <html>
+      <body>
+        <OlusoProvider options={{ apiKey: process.env.NEXT_PUBLIC_OLUSO_API_KEY! }}>
+          {children}
+        </OlusoProvider>
+      </body>
+    </html>
+  );
+}
+```
+
+```tsx
+// app/dashboard/error.tsx
+'use client';
+import { useOlusoErrorEffect } from '@oluso/nextjs/client';
+
+export default function Error({ error, reset }: { error: Error & { digest?: string }; reset: () => void }) {
+  useOlusoErrorEffect(error); // reports once per distinct error, including error.digest
+  return (
+    <div>
+      Something went wrong.
+      <button onClick={reset}>Try again</button>
+    </div>
+  );
+}
+```
+
+`useOlusoErrorEffect` needs an `<OlusoProvider>` above it in the tree, which rules out `global-error.tsx` specifically — it replaces the root layout the provider would normally live in. For that file, construct an `OlusoClient` directly instead:
+
+```tsx
+// app/global-error.tsx
+'use client';
+import { OlusoClient } from '@oluso/nextjs/client';
+import { useEffect } from 'react';
+
+const client = new OlusoClient({ apiKey: process.env.NEXT_PUBLIC_OLUSO_API_KEY! });
+
+export default function GlobalError({ error }: { error: Error & { digest?: string } }) {
+  useEffect(() => {
+    client.captureException(error);
+  }, [error]);
+
+  return (
+    <html>
+      <body>Something went seriously wrong.</body>
+    </html>
+  );
+}
+```
+
+`useOluso()` and `ErrorBoundary` are also re-exported from `@oluso/nextjs/client` for manual reporting and non-route error boundaries, same as `@oluso/react`.
+
+## Breadcrumbs & User Context (server-side)
+
+`oluso.addBreadcrumb`/`setUserContext`/`setCustomContext` are scoped to the current request when called inside a `with*` wrapper (via `AsyncLocalStorage`), so concurrent requests on a self-hosted, long-running Next.js server don't bleed context into each other:
+
+```ts
+export const POST = withOluso(oluso, async (req) => {
+  const user = await getUser(req);
+  oluso.setUserContext({ id: user.id });
+  oluso.addBreadcrumb({ message: 'checkout started', category: 'action' });
+
+  try {
+    await doCheckout();
+  } catch (err) {
+    oluso.captureException(err, { step: 'checkout' });
+    return Response.json({ error: 'checkout failed' }, { status: 500 });
+  }
+
+  return Response.json({ ok: true });
+});
+```
+
+## Advanced Configuration
+
+```ts
+new Oluso({
+  apiKey: 'your-api-key',
+  endpoint: 'https://api.oluso.dev/api/v1/error/report', // override for self-hosting
+  environment: 'staging',
+  defaultSeverity: 'medium',
+  maxBreadcrumbs: 50,
+  maxErrorsPerMinute: 100,
+  sensitiveKeys: ['ssn', 'internal_id'],
+  shouldReport: (err) => !err.message.includes('expected'),
+});
+```
+
+## License
+
+MIT

package/dist/api-route.d.ts

@@ -0,0 +1,15 @@
+import type { NextApiHandler } from 'next';
+import { Oluso } from './client';
+/**
+ * Wraps a Pages Router API route (`pages/api/**\/*.ts`). Reports thrown
+ * errors and 5xx responses, with a request-scoped breadcrumb trail around
+ * the handler call.
+ *
+ * ```ts
+ * // pages/api/widgets.ts
+ * export default withOlusoApiRoute(oluso, async (req, res) => {
+ *   ...
+ * });
+ * ```
+ */
+export declare function withOlusoApiRoute(oluso: Oluso, handler: NextApiHandler): NextApiHandler;

package/dist/api-route.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withOlusoApiRoute = withOlusoApiRoute;
+const request_context_1 = require("./request-context");
+/**
+ * Wraps a Pages Router API route (`pages/api/**\/*.ts`). Reports thrown
+ * errors and 5xx responses, with a request-scoped breadcrumb trail around
+ * the handler call.
+ *
+ * ```ts
+ * // pages/api/widgets.ts
+ * export default withOlusoApiRoute(oluso, async (req, res) => {
+ *   ...
+ * });
+ * ```
+ */
+function withOlusoApiRoute(oluso, handler) {
+    return function olusoApiHandler(req, res) {
+        return oluso.runInContext(async () => {
+            oluso.addBreadcrumb({
+                message: `${req.method} ${req.url}`,
+                level: 'info',
+                category: 'http',
+                data: { method: req.method, url: req.url },
+            });
+            try {
+                await handler(req, res);
+                if (res.statusCode >= 500) {
+                    const error = new Error(`Server error: ${res.statusCode} - ${req.method} ${req.url}`);
+                    error.severity = 'critical';
+                    await oluso.reportError(error, (0, request_context_1.fromApiRequest)(req));
+                }
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                err.severity = 'critical';
+                await oluso.reportError(err, (0, request_context_1.fromApiRequest)(req));
+                throw error;
+            }
+        });
+    };
+}

package/dist/client.d.ts

@@ -0,0 +1,37 @@
+import { UserContext } from '@oluso/core';
+import { NextjsContextManager } from './context';
+import { OlusoNextjsOptions, RequestContext } from './types';
+/**
+ * Server-side Oluso client for Next.js. Unlike @oluso/node's `Oluso`, this
+ * has no dependency on Node's `http`/`https`/`os` modules or on
+ * `process.on(...)` at construction time -- it works unchanged on both the
+ * Node.js and Edge runtimes Next.js can run route handlers, middleware, and
+ * Server Components on. For Client Components, use the browser-backed
+ * pieces exported from `@oluso/nextjs/client` instead.
+ */
+export declare class Oluso {
+    private options;
+    private endpoint;
+    private contextManager;
+    private sanitizer;
+    private rateLimiter;
+    private offlineQueue;
+    constructor(options: OlusoNextjsOptions);
+    /**
+     * Runs `callback` inside a fresh request-scoped context. Route/middleware
+     * wrappers in this package call this once per request; call it yourself
+     * if you're reporting from somewhere those wrappers don't cover.
+     */
+    runInContext<T>(callback: () => T): T;
+    addBreadcrumb(breadcrumb: Parameters<NextjsContextManager['addBreadcrumb']>[0]): void;
+    setUserContext(user: UserContext): void;
+    setCustomContext(key: string, value: any): void;
+    captureException(error: Error, customContext?: Record<string, any>): Promise<void>;
+    flush(): Promise<void>;
+    reportError(error: Error, request?: RequestContext): Promise<void>;
+    private buildErrorContext;
+    private sanitizeRequest;
+    private sendReport;
+    private generateErrorTitle;
+}
+export default Oluso;

package/dist/client.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Oluso = void 0;
+const core_1 = require("@oluso/core");
+const transport_1 = require("./transport");
+const queue_1 = require("./queue");
+const context_1 = require("./context");
+const runtime_1 = require("./runtime");
+const DEFAULT_ENDPOINT = 'https://api.oluso.dev/api/v1/error/report';
+/**
+ * Server-side Oluso client for Next.js. Unlike @oluso/node's `Oluso`, this
+ * has no dependency on Node's `http`/`https`/`os` modules or on
+ * `process.on(...)` at construction time -- it works unchanged on both the
+ * Node.js and Edge runtimes Next.js can run route handlers, middleware, and
+ * Server Components on. For Client Components, use the browser-backed
+ * pieces exported from `@oluso/nextjs/client` instead.
+ */
+class Oluso {
+    constructor(options) {
+        this.options = {
+            logToConsole: true,
+            timeout: 5000,
+            environment: 'production',
+            defaultSeverity: 'medium',
+            maxBreadcrumbs: 30,
+            enableOfflineQueue: true,
+            maxQueueSize: 100,
+            maxErrorsPerMinute: 60,
+            ...options,
+        };
+        this.endpoint = this.options.endpoint || DEFAULT_ENDPOINT;
+        this.contextManager = new context_1.NextjsContextManager(this.options.maxBreadcrumbs);
+        this.sanitizer = new core_1.Sanitizer(this.options.sensitiveKeys);
+        this.rateLimiter = new core_1.RateLimiter(this.options.maxErrorsPerMinute);
+        this.offlineQueue = new queue_1.OfflineQueue(this.options.maxQueueSize);
+    }
+    /**
+     * Runs `callback` inside a fresh request-scoped context. Route/middleware
+     * wrappers in this package call this once per request; call it yourself
+     * if you're reporting from somewhere those wrappers don't cover.
+     */
+    runInContext(callback) {
+        return this.contextManager.run(callback);
+    }
+    addBreadcrumb(breadcrumb) {
+        this.contextManager.addBreadcrumb(breadcrumb);
+    }
+    setUserContext(user) {
+        this.contextManager.setUserContext(user);
+    }
+    setCustomContext(key, value) {
+        this.contextManager.setCustomContext(key, value);
+    }
+    captureException(error, customContext) {
+        if (customContext) {
+            for (const [key, value] of Object.entries(customContext)) {
+                this.setCustomContext(key, value);
+            }
+        }
+        return this.reportError(error);
+    }
+    async flush() {
+        await this.offlineQueue.processQueue((report) => (0, transport_1.sendErrorReport)(this.endpoint, report, {
+            apiKey: this.options.apiKey,
+            timeout: this.options.timeout,
+        }));
+    }
+    reportError(error, request) {
+        if (this.options.shouldReport && !this.options.shouldReport(error)) {
+            return Promise.resolve();
+        }
+        if (!this.rateLimiter.canSend()) {
+            if (this.options.logToConsole) {
+                console.warn('[Oluso] Rate limit exceeded, error not reported');
+            }
+            return Promise.resolve();
+        }
+        if (this.options.logToConsole) {
+            console.error('[Oluso]', error);
+        }
+        const context = this.buildErrorContext(request);
+        const fingerprint = this.options.fingerprint
+            ? this.options.fingerprint(error, context)
+            : (0, core_1.generateFingerprint)(error, context);
+        const report = {
+            title: this.generateErrorTitle(error),
+            message: error.message,
+            stack_trace: error.stack,
+            environment: this.options.environment,
+            severity: error.severity || this.options.defaultSeverity || 'medium',
+            tags: this.options.tags || [],
+            fingerprint,
+            context,
+            timestamp: Date.now(),
+        };
+        return this.sendReport(report);
+    }
+    buildErrorContext(request) {
+        const managed = this.contextManager.getContext();
+        return {
+            ...managed,
+            custom: {
+                ...managed.custom,
+                server: (0, runtime_1.getRuntimeServerContext)(),
+                ...(request ? { request: this.sanitizeRequest(request) } : {}),
+            },
+        };
+    }
+    sanitizeRequest(request) {
+        return {
+            ...request,
+            headers: request.headers ? this.sanitizer.sanitizeHeaders(request.headers) : undefined,
+            query: request.query ? this.sanitizer.sanitizeQuery(request.query) : undefined,
+            body: request.body !== undefined ? this.sanitizer.sanitizeBody(request.body) : undefined,
+        };
+    }
+    async sendReport(report) {
+        try {
+            await (0, transport_1.sendErrorReport)(this.endpoint, report, {
+                apiKey: this.options.apiKey,
+                timeout: this.options.timeout,
+            });
+            if (this.options.enableOfflineQueue && !this.offlineQueue.isEmpty()) {
+                this.offlineQueue
+                    .processQueue((queuedReport) => (0, transport_1.sendErrorReport)(this.endpoint, queuedReport, {
+                    apiKey: this.options.apiKey,
+                    timeout: this.options.timeout,
+                }))
+                    .catch(() => {
+                    // Silently fail queue processing
+                });
+            }
+        }
+        catch (err) {
+            if (this.options.enableOfflineQueue) {
+                this.offlineQueue.enqueue(report);
+            }
+        }
+    }
+    generateErrorTitle(error) {
+        const firstLine = error.message.split('\n')[0].trim();
+        if (firstLine && firstLine.length > 0) {
+            return firstLine.length <= 100 ? firstLine : `${firstLine.substring(0, 97)}...`;
+        }
+        return `${error.constructor.name} Error`;
+    }
+}
+exports.Oluso = Oluso;
+exports.default = Oluso;

package/dist/context.d.ts

@@ -0,0 +1,25 @@
+import { Breadcrumb, ErrorContext, UserContext } from '@oluso/core';
+/**
+ * Request-scoped breadcrumb/user/context store, the Next.js counterpart to
+ * @oluso/node's ContextManager. Route/middleware wrappers call `run()` once
+ * per request so concurrent requests on a long-running Node server (e.g.
+ * self-hosted via `next start`) don't bleed breadcrumbs into each other.
+ *
+ * Falls back to a single shared store when called outside `run()` -- e.g. a
+ * Server Component rendered without an explicit wrapper, or a call made
+ * from module scope during startup -- mirroring @oluso/browser's flat
+ * (non-request-scoped) behavior rather than silently dropping the data.
+ */
+export declare class NextjsContextManager {
+    private storage;
+    private globalStore;
+    private maxBreadcrumbs;
+    constructor(maxBreadcrumbs?: number);
+    run<T>(callback: () => T): T;
+    private store;
+    addBreadcrumb(breadcrumb: Omit<Breadcrumb, 'timestamp'>): void;
+    setUserContext(user: UserContext): void;
+    setCustomContext(key: string, value: any): void;
+    getContext(): Partial<ErrorContext>;
+}
+export default NextjsContextManager;

package/dist/context.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NextjsContextManager = void 0;
+function createStorage() {
+    try {
+        // AsyncLocalStorage is on Vercel/Next.js's list of supported Edge
+        // Runtime APIs (Next uses it internally for next/headers), but this is
+        // guarded the same defensive way @oluso/node guards worker_threads/
+        // cluster: if some other Edge-like environment this package ends up
+        // running in doesn't have it, fall back rather than crash.
+        const { AsyncLocalStorage } = require('async_hooks');
+        return new AsyncLocalStorage();
+    }
+    catch (_a) {
+        let current;
+        return {
+            run(data, callback) {
+                current = data;
+                try {
+                    return callback();
+                }
+                finally {
+                    current = undefined;
+                }
+            },
+            getStore() {
+                return current;
+            },
+        };
+    }
+}
+/**
+ * Request-scoped breadcrumb/user/context store, the Next.js counterpart to
+ * @oluso/node's ContextManager. Route/middleware wrappers call `run()` once
+ * per request so concurrent requests on a long-running Node server (e.g.
+ * self-hosted via `next start`) don't bleed breadcrumbs into each other.
+ *
+ * Falls back to a single shared store when called outside `run()` -- e.g. a
+ * Server Component rendered without an explicit wrapper, or a call made
+ * from module scope during startup -- mirroring @oluso/browser's flat
+ * (non-request-scoped) behavior rather than silently dropping the data.
+ */
+class NextjsContextManager {
+    constructor(maxBreadcrumbs = 30) {
+        this.globalStore = { breadcrumbs: [], customContext: {} };
+        this.storage = createStorage();
+        this.maxBreadcrumbs = maxBreadcrumbs;
+    }
+    run(callback) {
+        return this.storage.run({ breadcrumbs: [], customContext: {} }, callback);
+    }
+    store() {
+        var _a;
+        return (_a = this.storage.getStore()) !== null && _a !== void 0 ? _a : this.globalStore;
+    }
+    addBreadcrumb(breadcrumb) {
+        const store = this.store();
+        store.breadcrumbs.push({ ...breadcrumb, timestamp: Date.now() });
+        if (store.breadcrumbs.length > this.maxBreadcrumbs) {
+            store.breadcrumbs.shift();
+        }
+    }
+    setUserContext(user) {
+        this.store().userContext = user;
+    }
+    setCustomContext(key, value) {
+        this.store().customContext[key] = value;
+    }
+    getContext() {
+        const store = this.store();
+        return {
+            breadcrumbs: store.breadcrumbs,
+            user: store.userContext,
+            custom: store.customContext,
+        };
+    }
+}
+exports.NextjsContextManager = NextjsContextManager;
+exports.default = NextjsContextManager;

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from '@oluso/core';
+export type { OlusoNextjsOptions, RequestContext, RuntimeServerContext } from './types';
+export { Oluso } from './client';
+export { withOluso } from './route-handler';
+export type { RouteHandler } from './route-handler';
+export { withOlusoApiRoute } from './api-route';
+export { withOlusoMiddleware } from './middleware';
+export { fromFetchRequest, fromApiRequest } from './request-context';
+export { registerOlusoProcessHandlers, createOnRequestError, } from './instrumentation';
+export type { NextRequestErrorInfo, NextRequestErrorContext } from './instrumentation';

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOnRequestError = exports.registerOlusoProcessHandlers = exports.fromApiRequest = exports.fromFetchRequest = exports.withOlusoMiddleware = exports.withOlusoApiRoute = exports.withOluso = exports.Oluso = void 0;
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("@oluso/core"), exports);
+var client_1 = require("./client");
+Object.defineProperty(exports, "Oluso", { enumerable: true, get: function () { return client_1.Oluso; } });
+var route_handler_1 = require("./route-handler");
+Object.defineProperty(exports, "withOluso", { enumerable: true, get: function () { return route_handler_1.withOluso; } });
+var api_route_1 = require("./api-route");
+Object.defineProperty(exports, "withOlusoApiRoute", { enumerable: true, get: function () { return api_route_1.withOlusoApiRoute; } });
+var middleware_1 = require("./middleware");
+Object.defineProperty(exports, "withOlusoMiddleware", { enumerable: true, get: function () { return middleware_1.withOlusoMiddleware; } });
+var request_context_1 = require("./request-context");
+Object.defineProperty(exports, "fromFetchRequest", { enumerable: true, get: function () { return request_context_1.fromFetchRequest; } });
+Object.defineProperty(exports, "fromApiRequest", { enumerable: true, get: function () { return request_context_1.fromApiRequest; } });
+var instrumentation_1 = require("./instrumentation");
+Object.defineProperty(exports, "registerOlusoProcessHandlers", { enumerable: true, get: function () { return instrumentation_1.registerOlusoProcessHandlers; } });
+Object.defineProperty(exports, "createOnRequestError", { enumerable: true, get: function () { return instrumentation_1.createOnRequestError; } });

package/dist/instrumentation.d.ts

@@ -0,0 +1,48 @@
+import { Oluso } from './client';
+/**
+ * Registers `process.on('uncaughtException'/'unhandledRejection', ...)`
+ * handlers, mirroring @oluso/node's global handlers. Call this from the
+ * `register()` export of your `instrumentation.ts` -- Next.js calls
+ * `register()` once per server instance, before any other code runs, which
+ * is the one place in a Next.js app that's guaranteed to run exactly once
+ * (a module-scope side effect in a route file can run once per route
+ * per worker, not once for the whole server).
+ *
+ * No-ops on the Edge runtime: `process.on` isn't available there, and
+ * `register()` itself already runs there too (Next.js calls it once per
+ * runtime the app uses), so this has to check rather than assume Node.
+ */
+export declare function registerOlusoProcessHandlers(oluso: Oluso): void;
+export interface NextRequestErrorInfo {
+    path: string;
+    method: string;
+    headers: Record<string, string>;
+}
+export interface NextRequestErrorContext {
+    routerKind?: 'Pages Router' | 'App Router';
+    routePath?: string;
+    routeType?: 'render' | 'route' | 'action' | 'middleware';
+}
+/**
+ * Builds the `onRequestError` export for `instrumentation.ts` -- the hook
+ * Next.js (15+) calls for errors from Server Components, Route Handlers,
+ * Server Actions, and Middleware, whether or not they're individually
+ * wrapped with `withOluso`/`withOlusoMiddleware`. This is the zero-config
+ * catch-all; the `with*` wrappers exist for the cases where you also want
+ * request-scoped breadcrumbs recorded *during* the handler, not just the
+ * failure itself.
+ *
+ * ```ts
+ * // instrumentation.ts
+ * import { Oluso, registerOlusoProcessHandlers, createOnRequestError } from '@oluso/nextjs';
+ *
+ * const oluso = new Oluso({ apiKey: process.env.OLUSO_API_KEY! });
+ *
+ * export async function register() {
+ *   registerOlusoProcessHandlers(oluso);
+ * }
+ *
+ * export const onRequestError = createOnRequestError(oluso);
+ * ```
+ */
+export declare function createOnRequestError(oluso: Oluso): (error: unknown, request: NextRequestErrorInfo, context: NextRequestErrorContext) => Promise<void>;

package/dist/instrumentation.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerOlusoProcessHandlers = registerOlusoProcessHandlers;
+exports.createOnRequestError = createOnRequestError;
+const runtime_1 = require("./runtime");
+/**
+ * Registers `process.on('uncaughtException'/'unhandledRejection', ...)`
+ * handlers, mirroring @oluso/node's global handlers. Call this from the
+ * `register()` export of your `instrumentation.ts` -- Next.js calls
+ * `register()` once per server instance, before any other code runs, which
+ * is the one place in a Next.js app that's guaranteed to run exactly once
+ * (a module-scope side effect in a route file can run once per route
+ * per worker, not once for the whole server).
+ *
+ * No-ops on the Edge runtime: `process.on` isn't available there, and
+ * `register()` itself already runs there too (Next.js calls it once per
+ * runtime the app uses), so this has to check rather than assume Node.
+ */
+function registerOlusoProcessHandlers(oluso) {
+    if (typeof process === 'undefined' || typeof process.on !== 'function')
+        return;
+    if ((0, runtime_1.getRuntime)() !== 'nodejs')
+        return;
+    process.on('uncaughtException', (error) => {
+        oluso.addBreadcrumb({
+            message: 'Uncaught exception occurred',
+            level: 'error',
+            category: 'error',
+        });
+        error.severity = 'critical';
+        oluso.reportError(error);
+    });
+    process.on('unhandledRejection', (reason) => {
+        oluso.addBreadcrumb({
+            message: 'Unhandled promise rejection',
+            level: 'error',
+            category: 'promise',
+        });
+        const error = reason instanceof Error ? reason : new Error(`Unhandled rejection: ${String(reason)}`);
+        error.severity = 'critical';
+        oluso.reportError(error);
+    });
+}
+/**
+ * Builds the `onRequestError` export for `instrumentation.ts` -- the hook
+ * Next.js (15+) calls for errors from Server Components, Route Handlers,
+ * Server Actions, and Middleware, whether or not they're individually
+ * wrapped with `withOluso`/`withOlusoMiddleware`. This is the zero-config
+ * catch-all; the `with*` wrappers exist for the cases where you also want
+ * request-scoped breadcrumbs recorded *during* the handler, not just the
+ * failure itself.
+ *
+ * ```ts
+ * // instrumentation.ts
+ * import { Oluso, registerOlusoProcessHandlers, createOnRequestError } from '@oluso/nextjs';
+ *
+ * const oluso = new Oluso({ apiKey: process.env.OLUSO_API_KEY! });
+ *
+ * export async function register() {
+ *   registerOlusoProcessHandlers(oluso);
+ * }
+ *
+ * export const onRequestError = createOnRequestError(oluso);
+ * ```
+ */
+function createOnRequestError(oluso) {
+    return async function onRequestError(error, request, context) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        err.severity = 'critical';
+        await oluso.reportError(err, {
+            url: request.path,
+            method: request.method,
+            headers: request.headers,
+            routeType: context.routeType === 'route'
+                ? 'route-handler'
+                : context.routeType === 'action'
+                    ? 'action'
+                    : context.routeType === 'middleware'
+                        ? 'middleware'
+                        : 'render',
+        });
+    };
+}

package/dist/middleware.d.ts

@@ -0,0 +1,15 @@
+import type { NextMiddleware } from 'next/server';
+import { Oluso } from './client';
+/**
+ * Wraps Next.js middleware (`middleware.ts`), which always runs on the Edge
+ * runtime. Reports thrown errors with a request-scoped breadcrumb trail,
+ * then re-throws so Next.js's own handling of the failure is unchanged.
+ *
+ * ```ts
+ * // middleware.ts
+ * export const middleware = withOlusoMiddleware(oluso, async (req) => {
+ *   ...
+ * });
+ * ```
+ */
+export declare function withOlusoMiddleware(oluso: Oluso, handler: NextMiddleware): NextMiddleware;

package/dist/middleware.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withOlusoMiddleware = withOlusoMiddleware;
+const request_context_1 = require("./request-context");
+/**
+ * Wraps Next.js middleware (`middleware.ts`), which always runs on the Edge
+ * runtime. Reports thrown errors with a request-scoped breadcrumb trail,
+ * then re-throws so Next.js's own handling of the failure is unchanged.
+ *
+ * ```ts
+ * // middleware.ts
+ * export const middleware = withOlusoMiddleware(oluso, async (req) => {
+ *   ...
+ * });
+ * ```
+ */
+function withOlusoMiddleware(oluso, handler) {
+    return function olusoMiddleware(req, event) {
+        return oluso.runInContext(async () => {
+            const url = new URL(req.url);
+            oluso.addBreadcrumb({
+                message: `${req.method} ${url.pathname}`,
+                level: 'info',
+                category: 'http',
+                data: { method: req.method, url: url.pathname },
+            });
+            try {
+                return await handler(req, event);
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                err.severity = 'critical';
+                await oluso.reportError(err, (0, request_context_1.fromFetchRequest)(req));
+                throw error;
+            }
+        });
+    };
+}

package/dist/queue.d.ts

@@ -0,0 +1,21 @@
+import { ErrorReport } from '@oluso/core';
+/**
+ * In-memory-only offline queue. Unlike @oluso/browser's queue, this has
+ * nothing to persist to (no localStorage on the server, and no disk write
+ * that would be safe to do implicitly on every request) -- it only smooths
+ * over a send failure that gets retried by a *later* error in the same warm
+ * process/instance. On serverless platforms where each invocation is a
+ * fresh process, a queued report that never gets a follow-up error to
+ * piggyback on is simply lost, same as it would be if reporting weren't
+ * retried at all.
+ */
+export declare class OfflineQueue {
+    private queue;
+    private maxSize;
+    private isProcessing;
+    constructor(maxSize?: number);
+    enqueue(report: ErrorReport): void;
+    isEmpty(): boolean;
+    processQueue(sendFn: (report: ErrorReport) => Promise<void>): Promise<void>;
+}
+export default OfflineQueue;

package/dist/queue.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OfflineQueue = void 0;
+/**
+ * In-memory-only offline queue. Unlike @oluso/browser's queue, this has
+ * nothing to persist to (no localStorage on the server, and no disk write
+ * that would be safe to do implicitly on every request) -- it only smooths
+ * over a send failure that gets retried by a *later* error in the same warm
+ * process/instance. On serverless platforms where each invocation is a
+ * fresh process, a queued report that never gets a follow-up error to
+ * piggyback on is simply lost, same as it would be if reporting weren't
+ * retried at all.
+ */
+class OfflineQueue {
+    constructor(maxSize = 100) {
+        this.queue = [];
+        this.isProcessing = false;
+        this.maxSize = maxSize;
+    }
+    enqueue(report) {
+        this.queue.push({ report, timestamp: Date.now(), retries: 0 });
+        if (this.queue.length > this.maxSize) {
+            this.queue.shift();
+        }
+    }
+    isEmpty() {
+        return this.queue.length === 0;
+    }
+    async processQueue(sendFn) {
+        if (this.isProcessing || this.isEmpty())
+            return;
+        this.isProcessing = true;
+        try {
+            while (this.queue.length > 0) {
+                const queued = this.queue[0];
+                try {
+                    await sendFn(queued.report);
+                    this.queue.shift();
+                }
+                catch (_a) {
+                    queued.retries++;
+                    if (queued.retries >= 3) {
+                        this.queue.shift();
+                    }
+                    break;
+                }
+            }
+        }
+        finally {
+            this.isProcessing = false;
+        }
+    }
+}
+exports.OfflineQueue = OfflineQueue;
+exports.default = OfflineQueue;

package/dist/request-context.d.ts

@@ -0,0 +1,15 @@
+import type { NextApiRequest } from 'next';
+import { RequestContext } from './types';
+/**
+ * Builds a RequestContext from a Fetch API `Request` (App Router route
+ * handlers, middleware). Deliberately never reads `req.body` -- it's a
+ * stream that can only be consumed once, and doing it here would leave
+ * nothing for the actual handler to read.
+ */
+export declare function fromFetchRequest(req: Request): RequestContext;
+/**
+ * Builds a RequestContext from a Pages Router `NextApiRequest`, which --
+ * unlike the App Router's Fetch API Request -- already has its body parsed
+ * for us, so it's safe to include here.
+ */
+export declare function fromApiRequest(req: NextApiRequest): RequestContext;

package/dist/request-context.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromFetchRequest = fromFetchRequest;
+exports.fromApiRequest = fromApiRequest;
+/**
+ * Builds a RequestContext from a Fetch API `Request` (App Router route
+ * handlers, middleware). Deliberately never reads `req.body` -- it's a
+ * stream that can only be consumed once, and doing it here would leave
+ * nothing for the actual handler to read.
+ */
+function fromFetchRequest(req) {
+    const headers = {};
+    req.headers.forEach((value, key) => {
+        headers[key] = value;
+    });
+    const url = new URL(req.url);
+    const query = {};
+    url.searchParams.forEach((value, key) => {
+        query[key] = value;
+    });
+    return {
+        url: url.pathname + url.search,
+        method: req.method,
+        headers,
+        query,
+    };
+}
+/**
+ * Builds a RequestContext from a Pages Router `NextApiRequest`, which --
+ * unlike the App Router's Fetch API Request -- already has its body parsed
+ * for us, so it's safe to include here.
+ */
+function fromApiRequest(req) {
+    return {
+        url: req.url || '',
+        method: req.method || '',
+        headers: req.headers,
+        query: req.query,
+        body: req.body,
+    };
+}

package/dist/route-handler.d.ts

@@ -0,0 +1,20 @@
+import { Oluso } from './client';
+export type RouteHandler<Ctx = any> = (req: Request, ctx: Ctx) => Response | Promise<Response>;
+/**
+ * Wraps an App Router route handler (`app/**\/route.ts`). Reports thrown
+ * errors and 5xx responses, with a request-scoped breadcrumb trail around
+ * the handler call, then re-throws / passes the response through unchanged
+ * so Next.js's own error handling still runs.
+ *
+ * ```ts
+ * // app/api/widgets/route.ts
+ * export const GET = withOluso(oluso, async (req) => {
+ *   ...
+ * });
+ * ```
+ *
+ * Each exported method (GET/POST/...) needs its own `withOluso(...)` call --
+ * Next.js dispatches by which named export exists, same reason
+ * @oluso/node's Express adapter needs two separate functions instead of one.
+ */
+export declare function withOluso<Ctx = any>(oluso: Oluso, handler: RouteHandler<Ctx>): RouteHandler<Ctx>;

package/dist/route-handler.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withOluso = withOluso;
+const request_context_1 = require("./request-context");
+/**
+ * Wraps an App Router route handler (`app/**\/route.ts`). Reports thrown
+ * errors and 5xx responses, with a request-scoped breadcrumb trail around
+ * the handler call, then re-throws / passes the response through unchanged
+ * so Next.js's own error handling still runs.
+ *
+ * ```ts
+ * // app/api/widgets/route.ts
+ * export const GET = withOluso(oluso, async (req) => {
+ *   ...
+ * });
+ * ```
+ *
+ * Each exported method (GET/POST/...) needs its own `withOluso(...)` call --
+ * Next.js dispatches by which named export exists, same reason
+ * @oluso/node's Express adapter needs two separate functions instead of one.
+ */
+function withOluso(oluso, handler) {
+    return function olusoRouteHandler(req, ctx) {
+        return oluso.runInContext(async () => {
+            const url = new URL(req.url);
+            oluso.addBreadcrumb({
+                message: `${req.method} ${url.pathname}`,
+                level: 'info',
+                category: 'http',
+                data: { method: req.method, url: url.pathname },
+            });
+            try {
+                const res = await handler(req, ctx);
+                if (res.status >= 500) {
+                    const error = new Error(`Server error: ${res.status} - ${req.method} ${url.pathname}`);
+                    error.severity = 'critical';
+                    await oluso.reportError(error, (0, request_context_1.fromFetchRequest)(req));
+                }
+                return res;
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                err.severity = 'critical';
+                await oluso.reportError(err, (0, request_context_1.fromFetchRequest)(req));
+                throw error;
+            }
+        });
+    };
+}

package/dist/runtime.d.ts

@@ -0,0 +1,13 @@
+import { RuntimeServerContext } from './types';
+/**
+ * `process.env.NEXT_RUNTIME` is Next.js's own documented way of telling
+ * `nodejs` and `edge` execution apart at runtime (it's how their own
+ * instrumentation.ts examples branch). Edge has no `os` module and no
+ * `process.memoryUsage`/`process.uptime`, so anything Node-only has to be
+ * gated behind this check rather than just feature-detected -- some Edge
+ * polyfills of `process` are convincing enough that a bare try/catch around
+ * `os.hostname()` isn't a reliable signal on its own.
+ */
+export declare function getRuntime(): 'nodejs' | 'edge';
+export declare function getRuntimeServerContext(): RuntimeServerContext;
+export default getRuntimeServerContext;

package/dist/runtime.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRuntime = getRuntime;
+exports.getRuntimeServerContext = getRuntimeServerContext;
+/**
+ * `process.env.NEXT_RUNTIME` is Next.js's own documented way of telling
+ * `nodejs` and `edge` execution apart at runtime (it's how their own
+ * instrumentation.ts examples branch). Edge has no `os` module and no
+ * `process.memoryUsage`/`process.uptime`, so anything Node-only has to be
+ * gated behind this check rather than just feature-detected -- some Edge
+ * polyfills of `process` are convincing enough that a bare try/catch around
+ * `os.hostname()` isn't a reliable signal on its own.
+ */
+function getRuntime() {
+    if (typeof process !== 'undefined' && process.env && process.env.NEXT_RUNTIME === 'edge') {
+        return 'edge';
+    }
+    return 'nodejs';
+}
+function getRuntimeServerContext() {
+    const runtime = getRuntime();
+    if (runtime === 'edge') {
+        return {
+            runtime,
+            nodeVersion: typeof process !== 'undefined' ? process.version : undefined,
+        };
+    }
+    try {
+        const os = require('os');
+        const memUsage = process.memoryUsage();
+        return {
+            runtime,
+            hostname: os.hostname(),
+            platform: `${os.platform()} ${os.release()}`,
+            nodeVersion: process.version,
+            memory: {
+                used: memUsage.heapUsed,
+                total: memUsage.heapTotal,
+            },
+            uptime: process.uptime(),
+        };
+    }
+    catch (_a) {
+        return { runtime };
+    }
+}
+exports.default = getRuntimeServerContext;

package/dist/transport.d.ts

@@ -0,0 +1,14 @@
+import { ErrorReport } from '@oluso/core';
+interface SendOptions {
+    apiKey: string;
+    timeout?: number;
+}
+/**
+ * Send an error report via fetch. Works unchanged on both the Node.js and
+ * Edge runtimes Next.js supports (unlike @oluso/node's transport, which
+ * uses Node's http/https modules and would break on Edge). Never rejects
+ * with an unhandled path the caller has to catch differently -- a failed
+ * send just means the report gets queued.
+ */
+export declare function sendErrorReport(reportUrl: string, errorReport: ErrorReport, options: SendOptions): Promise<void>;
+export {};

package/dist/transport.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendErrorReport = sendErrorReport;
+/**
+ * Send an error report via fetch. Works unchanged on both the Node.js and
+ * Edge runtimes Next.js supports (unlike @oluso/node's transport, which
+ * uses Node's http/https modules and would break on Edge). Never rejects
+ * with an unhandled path the caller has to catch differently -- a failed
+ * send just means the report gets queued.
+ */
+function sendErrorReport(reportUrl, errorReport, options) {
+    const controller = typeof AbortController !== 'undefined' ? new AbortController() : undefined;
+    const timeoutId = controller
+        ? setTimeout(() => controller.abort(), options.timeout || 5000)
+        : undefined;
+    return fetch(reportUrl, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'x-oluso-signature': options.apiKey,
+        },
+        body: JSON.stringify(errorReport),
+        signal: controller === null || controller === void 0 ? void 0 : controller.signal,
+    })
+        .then((res) => {
+        if (!res.ok) {
+            console.error(`[Oluso] Error reporting failed with status ${res.status}`);
+            throw new Error(`Oluso reporting failed with status ${res.status}`);
+        }
+    })
+        .catch((err) => {
+        console.error('[Oluso] Failed to send error report:', (err === null || err === void 0 ? void 0 : err.message) || err);
+        throw err;
+    })
+        .finally(() => {
+        if (timeoutId)
+            clearTimeout(timeoutId);
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,30 @@
+import { BaseOlusoOptions } from '@oluso/core';
+export interface OlusoNextjsOptions extends BaseOlusoOptions {
+}
+/**
+ * Request info attached to an error report. Deliberately narrower than the
+ * Node adapter's RequestContext -- the App Router's `Request` body is a
+ * stream that can only be read once, and reading it here would leave
+ * nothing for the actual route handler to consume, so `body` is only ever
+ * populated from the Pages Router (`NextApiRequest` already parses it).
+ */
+export interface RequestContext {
+    url: string;
+    method: string;
+    headers?: Record<string, string>;
+    query?: Record<string, any>;
+    body?: any;
+    /** Which Next.js surface the request came through, when known. */
+    routeType?: 'route-handler' | 'api-route' | 'middleware' | 'render' | 'action';
+}
+export interface RuntimeServerContext {
+    runtime: 'nodejs' | 'edge';
+    hostname?: string;
+    platform?: string;
+    nodeVersion?: string;
+    memory?: {
+        used: number;
+        total: number;
+    };
+    uptime?: number;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/use-oluso-error-effect.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Reports the error Next.js hands to an `error.tsx` boundary. Meant to be
+ * called from the top of that file:
+ *
+ * ```tsx
+ * 'use client';
+ * import { useOlusoErrorEffect } from '@oluso/nextjs/client';
+ *
+ * export default function Error({ error, reset }: { error: Error & { digest?: string }; reset: () => void }) {
+ *   useOlusoErrorEffect(error);
+ *   return <div>Something went wrong <button onClick={reset}>Try again</button></div>;
+ * }
+ * ```
+ *
+ * Must be used within an `<OlusoProvider>` higher in the tree -- which
+ * rules out `global-error.tsx` specifically, since it replaces the root
+ * layout that the provider would normally live in. For that file, construct
+ * an `OlusoClient` directly instead of using this hook.
+ *
+ * Reports in a `useEffect` (not during render) since `error.tsx` re-renders
+ * on every `reset()` attempt with the same error object until it's actually
+ * resolved -- reporting during render would re-report on each retry render,
+ * not just the first.
+ */
+export declare function useOlusoErrorEffect(error: Error & {
+    digest?: string;
+}): void;
+export default useOlusoErrorEffect;

package/dist/use-oluso-error-effect.js

@@ -0,0 +1,41 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOlusoErrorEffect = useOlusoErrorEffect;
+const react_1 = require("react");
+const react_2 = require("@oluso/react");
+/**
+ * Reports the error Next.js hands to an `error.tsx` boundary. Meant to be
+ * called from the top of that file:
+ *
+ * ```tsx
+ * 'use client';
+ * import { useOlusoErrorEffect } from '@oluso/nextjs/client';
+ *
+ * export default function Error({ error, reset }: { error: Error & { digest?: string }; reset: () => void }) {
+ *   useOlusoErrorEffect(error);
+ *   return <div>Something went wrong <button onClick={reset}>Try again</button></div>;
+ * }
+ * ```
+ *
+ * Must be used within an `<OlusoProvider>` higher in the tree -- which
+ * rules out `global-error.tsx` specifically, since it replaces the root
+ * layout that the provider would normally live in. For that file, construct
+ * an `OlusoClient` directly instead of using this hook.
+ *
+ * Reports in a `useEffect` (not during render) since `error.tsx` re-renders
+ * on every `reset()` attempt with the same error object until it's actually
+ * resolved -- reporting during render would re-report on each retry render,
+ * not just the first.
+ */
+function useOlusoErrorEffect(error) {
+    const client = (0, react_2.useOluso)();
+    const reportedRef = (0, react_1.useRef)(null);
+    (0, react_1.useEffect)(() => {
+        if (reportedRef.current === error)
+            return;
+        reportedRef.current = error;
+        client.captureException(error, error.digest ? { digest: error.digest } : undefined);
+    }, [error, client]);
+}
+exports.default = useOlusoErrorEffect;

package/package.json

@@ -0,0 +1,76 @@
+{
+    "name": "@oluso/nextjs",
+    "version": "1.0.0",
+    "description": "Oluso error monitoring for Next.js applications: instrumentation hooks, route/middleware wrappers, and React bindings for the App Router and Pages Router",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "default": "./dist/index.js"
+        },
+        "./client": {
+            "types": "./dist/client.d.ts",
+            "default": "./dist/client.js"
+        }
+    },
+    "sideEffects": false,
+    "scripts": {
+        "build": "tsc",
+        "test": "jest"
+    },
+    "keywords": [
+        "error",
+        "monitoring",
+        "reporting",
+        "nextjs",
+        "next",
+        "react",
+        "app-router",
+        "edge",
+        "error-tracking",
+        "error-monitoring",
+        "ai",
+        "crash-reporting",
+        "logging",
+        "debugging"
+    ],
+    "author": "David Ezeh",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/olusodotdev/oluso-js.git",
+        "directory": "packages/nextjs"
+    },
+    "bugs": {
+        "url": "https://github.com/olusodotdev/oluso-js/issues"
+    },
+    "homepage": "https://github.com/olusodotdev/oluso-js/tree/main/packages/nextjs#readme",
+    "files": [
+        "dist",
+        "README.md",
+        "LICENSE"
+    ],
+    "dependencies": {
+        "@oluso/core": "1.0.0",
+        "@oluso/react": "1.1.0",
+        "tslib": "^2.8.1"
+    },
+    "peerDependencies": {
+        "next": ">=13.4.0",
+        "react": ">=18.2.0"
+    },
+    "devDependencies": {
+        "@testing-library/react": "^16.0.0",
+        "@types/jest": "^30.0.0",
+        "@types/node": "^18.15.11",
+        "@types/react": "^18.2.0",
+        "jest": "^29.5.0",
+        "jest-environment-jsdom": "^29.5.0",
+        "next": "^14.2.0",
+        "react": "^18.2.0",
+        "react-dom": "^18.2.0",
+        "ts-jest": "^29.1.0",
+        "typescript": "^5.0.4"
+    }
+}