@metamask-previews/error-reporting-service 0.0.0-preview-d0685d1

package/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+
+- Initial release ([#5849](https://github.com/MetaMask/core/pull/5849))
+
+[Unreleased]: https://github.com/MetaMask/core/

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2025 MetaMask
+
+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

package/README.md

@@ -0,0 +1,204 @@
+# `@metamask/error-reporting-service`
+
+Reports errors to an external app such as Sentry but in an agnostic fashion.
+
+## Installation
+
+`yarn add @metamask/error-reporting-service`
+
+or
+
+`npm install @metamask/error-reporting-service`
+
+## Usage
+
+This package is designed to be used in another module via a messenger, but can also be used on its own if needed.
+
+### Using the service via a messenger
+
+In most cases, you will want to use the error reporting service in your module via a messenger object.
+
+In this example, we have a controller, and something bad happens, but we want to report an error instead of throwing it.
+
+#### 1. Controller file
+
+```typescript
+// We need to get the type for the `ErrorReportingService:captureException`
+// action.
+import type { ErrorReportingServiceCaptureExceptionAction } from '@metamask/error-reporting-service';
+
+// Now let's set up our controller, starting with the messenger.
+// Note that we grant the `ErrorReportingService:captureException` action to the
+// messenger.
+type AllowedActions = ErrorReportingServiceCaptureExceptionAction;
+type ExampleControllerMessenger = RestrictedMessenger<
+  'ExampleController',
+  AllowedActions,
+  never,
+  AllowedActions['type'],
+  never
+>;
+
+// Finally, we define our controller.
+class ExampleController extends BaseController<
+  'ExampleController',
+  ExampleControllerState,
+  ExampleControllerMessenger
+> {
+  doSomething() {
+    // Now imagine that we do something that produces an error and we want to
+    // report the error.
+    this.messagingSystem.call(
+      'ErrorReportingService:captureException',
+      new Error('Something went wrong'),
+    );
+  }
+}
+```
+
+#### 2A. Initialization file (browser)
+
+```typescript
+// We need a version of `captureException` from somewhere. Here, we are getting
+// it from `@sentry/browser`.
+import { captureException } from '@sentry/browser';
+
+// We also need to get the ErrorReportingService.
+import { ErrorReportingService } from '@metamask/error-reporting-service';
+
+// And we need our controller.
+import { ExampleController } from './example-controller';
+
+// We need to have a global messenger.
+const globalMessenger = new Messenger();
+
+// We need to create a restricted messenger for the ErrorReportingService, and
+// then we can create the service itself.
+const errorReportingServiceMessenger = globalMessenger.getRestricted({
+  allowedActions: [],
+  allowedEvents: [],
+});
+const errorReportingService = new ErrorReportingService({
+  messenger: errorReportingServiceMessenger,
+  captureException,
+});
+
+// Now we can create a restricted messenger for our controller, and then
+// we can create the controller too.
+// Note that we grant the `ErrorReportingService:captureException` action to the
+// messenger.
+const exampleControllerMessenger = globalMessenger.getRestricted({
+  allowedActions: ['ErrorReportingService:captureException'],
+  allowedEvents: [],
+});
+const exampleController = new ExampleController({
+  messenger: exampleControllerMessenger,
+});
+```
+
+#### 2B. Initialization file (React Native)
+
+```typescript
+// We need a version of `captureException` from somewhere. Here, we are getting
+// it from `@sentry/react-native`.
+import { captureException } from '@sentry/react-native';
+
+// We also need to get the ErrorReportingService.
+import { ErrorReportingService } from '@metamask/error-reporting-service';
+
+// And we need our controller.
+import { ExampleController } from './example-controller';
+
+// We need to have a global messenger.
+const globalMessenger = new Messenger();
+
+// We need to create a restricted messenger for the ErrorReportingService, and
+// then we can create the service itself.
+const errorReportingServiceMessenger = globalMessenger.getRestricted({
+  allowedActions: [],
+  allowedEvents: [],
+});
+const errorReportingService = new ErrorReportingService({
+  messenger: errorReportingServiceMessenger,
+  captureException,
+});
+
+// Now we can create a restricted messenger for our controller, and then
+// we can create the controller too.
+// Note that we grant the `ErrorReportingService:captureException` action to the
+// messenger.
+const exampleControllerMessenger = globalMessenger.getRestricted({
+  allowedActions: ['ErrorReportingService:captureException'],
+  allowedEvents: [],
+});
+const exampleController = new ExampleController({
+  messenger: exampleControllerMessenger,
+});
+```
+
+#### 3. Using the controller
+
+```typescript
+// Now this will report an error without throwing it.
+exampleController.doSomething();
+```
+
+### Using the service directly
+
+You probably don't need to use the service directly, but if you do, here's how.
+
+In this example, we have a function, and we use the error reporting service there.
+
+#### 1. Function file
+
+```typescript
+export function doSomething(
+  errorReportingService: AbstractErrorReportingService,
+) {
+  errorReportingService.captureException(new Error('Something went wrong'));
+}
+```
+
+#### 2A. Calling file (browser)
+
+```typescript
+// We need a version of `captureException` from somewhere. Here, we are getting
+it from `@sentry/browser`.
+import { captureException } from '@sentry/browser';
+
+// We also need to get the ErrorReportingService.
+import { ErrorReportingService } from '@metamask/error-reporting-service';
+
+// We also bring in our function.
+import { doSomething } from './do-something';
+
+// We create a new instance of the ErrorReportingService.
+const errorReportingService = new ErrorReportingService({ captureException });
+
+// Now we call our function, and it will report the error in Sentry.
+doSomething(errorReportingService);
+```
+
+#### 2A. Calling file (React Native)
+
+```typescript
+// We need a version of `captureException` from somewhere. Here, we are getting
+it from `@sentry/react-native`.
+import { captureException } from '@sentry/react-native';
+
+// We also need to get the ErrorReportingService.
+import { ErrorReportingService } from '@metamask/error-reporting-service';
+
+// We also bring in our function.
+import { doSomething } from './do-something';
+
+// We create a new instance of the ErrorReportingService.
+const errorReportingService = new ErrorReportingService({ captureException });
+
+// Now we call our function, and it will report the error in Sentry.
+doSomething(errorReportingService);
+```
+
+## Contributing
+
+This package is part of a monorepo. Instructions for contributing can be found in the [monorepo README](https://github.com/MetaMask/core#readme).

package/dist/error-reporting-service.cjs

@@ -0,0 +1,118 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ErrorReportingService_captureException, _ErrorReportingService_messenger;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorReportingService = void 0;
+/**
+ * `ErrorReportingService` is designed to log an error to an error reporting app
+ * such as Sentry, but in an agnostic fashion.
+ *
+ * @example
+ *
+ * In this example, we have a controller, and something bad happens, but we want
+ * to report an error instead of throwing it.
+ *
+ * ``` ts
+ * // === Controller file ===
+ *
+ * import type { ErrorReportingServiceCaptureExceptionAction } from '@metamask/error-reporting-service';
+ *
+ * // Define the messenger type for the controller.
+ * type AllowedActions = ErrorReportingServiceCaptureExceptionAction;
+ * type ExampleControllerMessenger = RestrictedMessenger<
+ *   'ExampleController',
+ *   AllowedActions,
+ *   never,
+ *   AllowedActions['type'],
+ *   never
+ * >;
+ *
+ * // Define the controller.
+ * class ExampleController extends BaseController<
+ *   'ExampleController',
+ *   ExampleControllerState,
+ *   ExampleControllerMessenger
+ * > {
+ *   doSomething() {
+ *     // Imagine that we do something that produces an error and we want to
+ *     // report the error.
+ *     this.messagingSystem.call(
+ *       'ErrorReportingService:captureException',
+ *       new Error('Something went wrong'),
+ *     );
+ *   }
+ * }
+ *
+ * // === Initialization file ===
+ *
+ * import { captureException } from '@sentry/browser';
+ * import { ErrorReportingService } from '@metamask/error-reporting-service';
+ * import { ExampleController } from './example-controller';
+ *
+ * // Create a global messenger.
+ * const globalMessenger = new Messenger();
+ *
+ * // Register handler for the `ErrorReportingService:captureException`
+ * // action in the global messenger.
+ * const errorReportingServiceMessenger = globalMessenger.getRestricted({
+ *   allowedActions: [],
+ *   allowedEvents: [],
+ * });
+ * const errorReportingService = new ErrorReportingService({
+ *   messenger: errorReportingServiceMessenger,
+ *   captureException,
+ * });
+ *
+ * const exampleControllerMessenger = globalMessenger.getRestricted({
+ *   allowedActions: ['ErrorReportingService:captureException'],
+ *   allowedEvents: [],
+ * });
+ * const exampleController = new ExampleController({
+ *   messenger: exampleControllerMessenger,
+ * });
+ *
+ * // === Somewhere else ===
+ *
+ * // Now this will report an error without throwing it.
+ * exampleController.doSomething();
+ * ```
+ */
+class ErrorReportingService {
+    /**
+     * Constructs a new ErrorReportingService.
+     *
+     * @param options - The options.
+     * @param options.messenger - The messenger suited to this
+     * ErrorReportingService.
+     * @param options.captureException - A function that stores the given error in
+     * the error reporting service.
+     */
+    constructor({ messenger, captureException }) {
+        _ErrorReportingService_captureException.set(this, void 0);
+        _ErrorReportingService_messenger.set(this, void 0);
+        __classPrivateFieldSet(this, _ErrorReportingService_messenger, messenger, "f");
+        __classPrivateFieldSet(this, _ErrorReportingService_captureException, captureException, "f");
+        __classPrivateFieldGet(this, _ErrorReportingService_messenger, "f").registerActionHandler('ErrorReportingService:captureException', __classPrivateFieldGet(this, _ErrorReportingService_captureException, "f").bind(this));
+    }
+    /**
+     * Reports the given error to an external location.
+     *
+     * @param error - The error to report.
+     */
+    captureException(error) {
+        __classPrivateFieldGet(this, _ErrorReportingService_captureException, "f").call(this, error);
+    }
+}
+exports.ErrorReportingService = ErrorReportingService;
+_ErrorReportingService_captureException = new WeakMap(), _ErrorReportingService_messenger = new WeakMap();
+//# sourceMappingURL=error-reporting-service.cjs.map

package/dist/error-reporting-service.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-reporting-service.cjs","sourceRoot":"","sources":["../src/error-reporting-service.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAuDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH,MAAa,qBAAqB;IAKhC;;;;;;;;OAQG;IACH,YAAY,EAAE,SAAS,EAAE,gBAAgB,EAAgC;QAbhE,0DAAoE;QAEpE,mDAA2C;QAYlD,uBAAA,IAAI,oCAAc,SAAS,MAAA,CAAC;QAC5B,uBAAA,IAAI,2CAAqB,gBAAgB,MAAA,CAAC;QAE1C,uBAAA,IAAI,wCAAW,CAAC,qBAAqB,CACnC,wCAAwC,EACxC,uBAAA,IAAI,+CAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,CAClC,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACH,gBAAgB,CAAC,KAAY;QAC3B,uBAAA,IAAI,+CAAkB,MAAtB,IAAI,EAAmB,KAAK,CAAC,CAAC;IAChC,CAAC;CACF;AAhCD,sDAgCC","sourcesContent":["import type { RestrictedMessenger } from '@metamask/base-controller';\n\n/**\n * The action which can be used to report an error.\n */\nexport type ErrorReportingServiceCaptureExceptionAction = {\n  type: 'ErrorReportingService:captureException';\n  handler: ErrorReportingService['captureException'];\n};\n\n/**\n * All actions that {@link ErrorReportingService} registers so that other\n * modules can call them.\n */\nexport type ErrorReportingServiceActions =\n  ErrorReportingServiceCaptureExceptionAction;\n\n/**\n * All events that {@link ErrorReportingService} publishes so that other modules\n * can subscribe to them.\n */\nexport type ErrorReportingServiceEvents = never;\n\n/**\n * All actions registered by other modules that {@link ErrorReportingService}\n * calls.\n */\ntype AllowedActions = never;\n\n/**\n * All events published by other modules that {@link ErrorReportingService}\n * subscribes to.\n */\ntype AllowedEvents = never;\n\n/**\n * The messenger restricted to actions and events that\n * {@link ErrorReportingService} needs to access.\n */\nexport type ErrorReportingServiceMessenger = RestrictedMessenger<\n  'ErrorReportingService',\n  ErrorReportingServiceActions | AllowedActions,\n  ErrorReportingServiceEvents | AllowedEvents,\n  AllowedActions['type'],\n  AllowedEvents['type']\n>;\n\n/**\n * The options that {@link ErrorReportingService} takes.\n */\ntype ErrorReportingServiceOptions = {\n  captureException: (error: unknown) => string;\n  messenger: ErrorReportingServiceMessenger;\n};\n\n/**\n * `ErrorReportingService` is designed to log an error to an error reporting app\n * such as Sentry, but in an agnostic fashion.\n *\n * @example\n *\n * In this example, we have a controller, and something bad happens, but we want\n * to report an error instead of throwing it.\n *\n * ``` ts\n * // === Controller file ===\n *\n * import type { ErrorReportingServiceCaptureExceptionAction } from '@metamask/error-reporting-service';\n *\n * // Define the messenger type for the controller.\n * type AllowedActions = ErrorReportingServiceCaptureExceptionAction;\n * type ExampleControllerMessenger = RestrictedMessenger<\n *   'ExampleController',\n *   AllowedActions,\n *   never,\n *   AllowedActions['type'],\n *   never\n * >;\n *\n * // Define the controller.\n * class ExampleController extends BaseController<\n *   'ExampleController',\n *   ExampleControllerState,\n *   ExampleControllerMessenger\n * > {\n *   doSomething() {\n *     // Imagine that we do something that produces an error and we want to\n *     // report the error.\n *     this.messagingSystem.call(\n *       'ErrorReportingService:captureException',\n *       new Error('Something went wrong'),\n *     );\n *   }\n * }\n *\n * // === Initialization file ===\n *\n * import { captureException } from '@sentry/browser';\n * import { ErrorReportingService } from '@metamask/error-reporting-service';\n * import { ExampleController } from './example-controller';\n *\n * // Create a global messenger.\n * const globalMessenger = new Messenger();\n *\n * // Register handler for the `ErrorReportingService:captureException`\n * // action in the global messenger.\n * const errorReportingServiceMessenger = globalMessenger.getRestricted({\n *   allowedActions: [],\n *   allowedEvents: [],\n * });\n * const errorReportingService = new ErrorReportingService({\n *   messenger: errorReportingServiceMessenger,\n *   captureException,\n * });\n *\n * const exampleControllerMessenger = globalMessenger.getRestricted({\n *   allowedActions: ['ErrorReportingService:captureException'],\n *   allowedEvents: [],\n * });\n * const exampleController = new ExampleController({\n *   messenger: exampleControllerMessenger,\n * });\n *\n * // === Somewhere else ===\n *\n * // Now this will report an error without throwing it.\n * exampleController.doSomething();\n * ```\n */\nexport class ErrorReportingService {\n  readonly #captureException: ErrorReportingServiceOptions['captureException'];\n\n  readonly #messenger: ErrorReportingServiceMessenger;\n\n  /**\n   * Constructs a new ErrorReportingService.\n   *\n   * @param options - The options.\n   * @param options.messenger - The messenger suited to this\n   * ErrorReportingService.\n   * @param options.captureException - A function that stores the given error in\n   * the error reporting service.\n   */\n  constructor({ messenger, captureException }: ErrorReportingServiceOptions) {\n    this.#messenger = messenger;\n    this.#captureException = captureException;\n\n    this.#messenger.registerActionHandler(\n      'ErrorReportingService:captureException',\n      this.#captureException.bind(this),\n    );\n  }\n\n  /**\n   * Reports the given error to an external location.\n   *\n   * @param error - The error to report.\n   */\n  captureException(error: Error): void {\n    this.#captureException(error);\n  }\n}\n"]}

package/dist/error-reporting-service.d.cts

@@ -0,0 +1,135 @@
+import type { RestrictedMessenger } from "@metamask/base-controller";
+/**
+ * The action which can be used to report an error.
+ */
+export type ErrorReportingServiceCaptureExceptionAction = {
+    type: 'ErrorReportingService:captureException';
+    handler: ErrorReportingService['captureException'];
+};
+/**
+ * All actions that {@link ErrorReportingService} registers so that other
+ * modules can call them.
+ */
+export type ErrorReportingServiceActions = ErrorReportingServiceCaptureExceptionAction;
+/**
+ * All events that {@link ErrorReportingService} publishes so that other modules
+ * can subscribe to them.
+ */
+export type ErrorReportingServiceEvents = never;
+/**
+ * All actions registered by other modules that {@link ErrorReportingService}
+ * calls.
+ */
+type AllowedActions = never;
+/**
+ * All events published by other modules that {@link ErrorReportingService}
+ * subscribes to.
+ */
+type AllowedEvents = never;
+/**
+ * The messenger restricted to actions and events that
+ * {@link ErrorReportingService} needs to access.
+ */
+export type ErrorReportingServiceMessenger = RestrictedMessenger<'ErrorReportingService', ErrorReportingServiceActions | AllowedActions, ErrorReportingServiceEvents | AllowedEvents, AllowedActions['type'], AllowedEvents['type']>;
+/**
+ * The options that {@link ErrorReportingService} takes.
+ */
+type ErrorReportingServiceOptions = {
+    captureException: (error: unknown) => string;
+    messenger: ErrorReportingServiceMessenger;
+};
+/**
+ * `ErrorReportingService` is designed to log an error to an error reporting app
+ * such as Sentry, but in an agnostic fashion.
+ *
+ * @example
+ *
+ * In this example, we have a controller, and something bad happens, but we want
+ * to report an error instead of throwing it.
+ *
+ * ``` ts
+ * // === Controller file ===
+ *
+ * import type { ErrorReportingServiceCaptureExceptionAction } from '@metamask/error-reporting-service';
+ *
+ * // Define the messenger type for the controller.
+ * type AllowedActions = ErrorReportingServiceCaptureExceptionAction;
+ * type ExampleControllerMessenger = RestrictedMessenger<
+ *   'ExampleController',
+ *   AllowedActions,
+ *   never,
+ *   AllowedActions['type'],
+ *   never
+ * >;
+ *
+ * // Define the controller.
+ * class ExampleController extends BaseController<
+ *   'ExampleController',
+ *   ExampleControllerState,
+ *   ExampleControllerMessenger
+ * > {
+ *   doSomething() {
+ *     // Imagine that we do something that produces an error and we want to
+ *     // report the error.
+ *     this.messagingSystem.call(
+ *       'ErrorReportingService:captureException',
+ *       new Error('Something went wrong'),
+ *     );
+ *   }
+ * }
+ *
+ * // === Initialization file ===
+ *
+ * import { captureException } from '@sentry/browser';
+ * import { ErrorReportingService } from '@metamask/error-reporting-service';
+ * import { ExampleController } from './example-controller';
+ *
+ * // Create a global messenger.
+ * const globalMessenger = new Messenger();
+ *
+ * // Register handler for the `ErrorReportingService:captureException`
+ * // action in the global messenger.
+ * const errorReportingServiceMessenger = globalMessenger.getRestricted({
+ *   allowedActions: [],
+ *   allowedEvents: [],
+ * });
+ * const errorReportingService = new ErrorReportingService({
+ *   messenger: errorReportingServiceMessenger,
+ *   captureException,
+ * });
+ *
+ * const exampleControllerMessenger = globalMessenger.getRestricted({
+ *   allowedActions: ['ErrorReportingService:captureException'],
+ *   allowedEvents: [],
+ * });
+ * const exampleController = new ExampleController({
+ *   messenger: exampleControllerMessenger,
+ * });
+ *
+ * // === Somewhere else ===
+ *
+ * // Now this will report an error without throwing it.
+ * exampleController.doSomething();
+ * ```
+ */
+export declare class ErrorReportingService {
+    #private;
+    /**
+     * Constructs a new ErrorReportingService.
+     *
+     * @param options - The options.
+     * @param options.messenger - The messenger suited to this
+     * ErrorReportingService.
+     * @param options.captureException - A function that stores the given error in
+     * the error reporting service.
+     */
+    constructor({ messenger, captureException }: ErrorReportingServiceOptions);
+    /**
+     * Reports the given error to an external location.
+     *
+     * @param error - The error to report.
+     */
+    captureException(error: Error): void;
+}
+export {};
+//# sourceMappingURL=error-reporting-service.d.cts.map

package/dist/error-reporting-service.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-reporting-service.d.cts","sourceRoot":"","sources":["../src/error-reporting-service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,kCAAkC;AAErE;;GAEG;AACH,MAAM,MAAM,2CAA2C,GAAG;IACxD,IAAI,EAAE,wCAAwC,CAAC;IAC/C,OAAO,EAAE,qBAAqB,CAAC,kBAAkB,CAAC,CAAC;CACpD,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,4BAA4B,GACtC,2CAA2C,CAAC;AAE9C;;;GAGG;AACH,MAAM,MAAM,2BAA2B,GAAG,KAAK,CAAC;AAEhD;;;GAGG;AACH,KAAK,cAAc,GAAG,KAAK,CAAC;AAE5B;;;GAGG;AACH,KAAK,aAAa,GAAG,KAAK,CAAC;AAE3B;;;GAGG;AACH,MAAM,MAAM,8BAA8B,GAAG,mBAAmB,CAC9D,uBAAuB,EACvB,4BAA4B,GAAG,cAAc,EAC7C,2BAA2B,GAAG,aAAa,EAC3C,cAAc,CAAC,MAAM,CAAC,EACtB,aAAa,CAAC,MAAM,CAAC,CACtB,CAAC;AAEF;;GAEG;AACH,KAAK,4BAA4B,GAAG;IAClC,gBAAgB,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,CAAC;IAC7C,SAAS,EAAE,8BAA8B,CAAC;CAC3C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH,qBAAa,qBAAqB;;IAKhC;;;;;;;;OAQG;gBACS,EAAE,SAAS,EAAE,gBAAgB,EAAE,EAAE,4BAA4B;IAUzE;;;;OAIG;IACH,gBAAgB,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;CAGrC"}

package/dist/error-reporting-service.d.mts

@@ -0,0 +1,135 @@
+import type { RestrictedMessenger } from "@metamask/base-controller";
+/**
+ * The action which can be used to report an error.
+ */
+export type ErrorReportingServiceCaptureExceptionAction = {
+    type: 'ErrorReportingService:captureException';
+    handler: ErrorReportingService['captureException'];
+};
+/**
+ * All actions that {@link ErrorReportingService} registers so that other
+ * modules can call them.
+ */
+export type ErrorReportingServiceActions = ErrorReportingServiceCaptureExceptionAction;
+/**
+ * All events that {@link ErrorReportingService} publishes so that other modules
+ * can subscribe to them.
+ */
+export type ErrorReportingServiceEvents = never;
+/**
+ * All actions registered by other modules that {@link ErrorReportingService}
+ * calls.
+ */
+type AllowedActions = never;
+/**
+ * All events published by other modules that {@link ErrorReportingService}
+ * subscribes to.
+ */
+type AllowedEvents = never;
+/**
+ * The messenger restricted to actions and events that
+ * {@link ErrorReportingService} needs to access.
+ */
+export type ErrorReportingServiceMessenger = RestrictedMessenger<'ErrorReportingService', ErrorReportingServiceActions | AllowedActions, ErrorReportingServiceEvents | AllowedEvents, AllowedActions['type'], AllowedEvents['type']>;
+/**
+ * The options that {@link ErrorReportingService} takes.
+ */
+type ErrorReportingServiceOptions = {
+    captureException: (error: unknown) => string;
+    messenger: ErrorReportingServiceMessenger;
+};
+/**
+ * `ErrorReportingService` is designed to log an error to an error reporting app
+ * such as Sentry, but in an agnostic fashion.
+ *
+ * @example
+ *
+ * In this example, we have a controller, and something bad happens, but we want
+ * to report an error instead of throwing it.
+ *
+ * ``` ts
+ * // === Controller file ===
+ *
+ * import type { ErrorReportingServiceCaptureExceptionAction } from '@metamask/error-reporting-service';
+ *
+ * // Define the messenger type for the controller.
+ * type AllowedActions = ErrorReportingServiceCaptureExceptionAction;
+ * type ExampleControllerMessenger = RestrictedMessenger<
+ *   'ExampleController',
+ *   AllowedActions,
+ *   never,
+ *   AllowedActions['type'],
+ *   never
+ * >;
+ *
+ * // Define the controller.
+ * class ExampleController extends BaseController<
+ *   'ExampleController',
+ *   ExampleControllerState,
+ *   ExampleControllerMessenger
+ * > {
+ *   doSomething() {
+ *     // Imagine that we do something that produces an error and we want to
+ *     // report the error.
+ *     this.messagingSystem.call(
+ *       'ErrorReportingService:captureException',
+ *       new Error('Something went wrong'),
+ *     );
+ *   }
+ * }
+ *
+ * // === Initialization file ===
+ *
+ * import { captureException } from '@sentry/browser';
+ * import { ErrorReportingService } from '@metamask/error-reporting-service';
+ * import { ExampleController } from './example-controller';
+ *
+ * // Create a global messenger.
+ * const globalMessenger = new Messenger();
+ *
+ * // Register handler for the `ErrorReportingService:captureException`
+ * // action in the global messenger.
+ * const errorReportingServiceMessenger = globalMessenger.getRestricted({
+ *   allowedActions: [],
+ *   allowedEvents: [],
+ * });
+ * const errorReportingService = new ErrorReportingService({
+ *   messenger: errorReportingServiceMessenger,
+ *   captureException,
+ * });
+ *
+ * const exampleControllerMessenger = globalMessenger.getRestricted({
+ *   allowedActions: ['ErrorReportingService:captureException'],
+ *   allowedEvents: [],
+ * });
+ * const exampleController = new ExampleController({
+ *   messenger: exampleControllerMessenger,
+ * });
+ *
+ * // === Somewhere else ===
+ *
+ * // Now this will report an error without throwing it.
+ * exampleController.doSomething();
+ * ```
+ */
+export declare class ErrorReportingService {
+    #private;
+    /**
+     * Constructs a new ErrorReportingService.
+     *
+     * @param options - The options.
+     * @param options.messenger - The messenger suited to this
+     * ErrorReportingService.
+     * @param options.captureException - A function that stores the given error in
+     * the error reporting service.
+     */
+    constructor({ messenger, captureException }: ErrorReportingServiceOptions);
+    /**
+     * Reports the given error to an external location.
+     *
+     * @param error - The error to report.
+     */
+    captureException(error: Error): void;
+}
+export {};
+//# sourceMappingURL=error-reporting-service.d.mts.map

package/dist/error-reporting-service.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-reporting-service.d.mts","sourceRoot":"","sources":["../src/error-reporting-service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,kCAAkC;AAErE;;GAEG;AACH,MAAM,MAAM,2CAA2C,GAAG;IACxD,IAAI,EAAE,wCAAwC,CAAC;IAC/C,OAAO,EAAE,qBAAqB,CAAC,kBAAkB,CAAC,CAAC;CACpD,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,4BAA4B,GACtC,2CAA2C,CAAC;AAE9C;;;GAGG;AACH,MAAM,MAAM,2BAA2B,GAAG,KAAK,CAAC;AAEhD;;;GAGG;AACH,KAAK,cAAc,GAAG,KAAK,CAAC;AAE5B;;;GAGG;AACH,KAAK,aAAa,GAAG,KAAK,CAAC;AAE3B;;;GAGG;AACH,MAAM,MAAM,8BAA8B,GAAG,mBAAmB,CAC9D,uBAAuB,EACvB,4BAA4B,GAAG,cAAc,EAC7C,2BAA2B,GAAG,aAAa,EAC3C,cAAc,CAAC,MAAM,CAAC,EACtB,aAAa,CAAC,MAAM,CAAC,CACtB,CAAC;AAEF;;GAEG;AACH,KAAK,4BAA4B,GAAG;IAClC,gBAAgB,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,CAAC;IAC7C,SAAS,EAAE,8BAA8B,CAAC;CAC3C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH,qBAAa,qBAAqB;;IAKhC;;;;;;;;OAQG;gBACS,EAAE,SAAS,EAAE,gBAAgB,EAAE,EAAE,4BAA4B;IAUzE;;;;OAIG;IACH,gBAAgB,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;CAGrC"}

package/dist/error-reporting-service.mjs

@@ -0,0 +1,114 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ErrorReportingService_captureException, _ErrorReportingService_messenger;
+/**
+ * `ErrorReportingService` is designed to log an error to an error reporting app
+ * such as Sentry, but in an agnostic fashion.
+ *
+ * @example
+ *
+ * In this example, we have a controller, and something bad happens, but we want
+ * to report an error instead of throwing it.
+ *
+ * ``` ts
+ * // === Controller file ===
+ *
+ * import type { ErrorReportingServiceCaptureExceptionAction } from '@metamask/error-reporting-service';
+ *
+ * // Define the messenger type for the controller.
+ * type AllowedActions = ErrorReportingServiceCaptureExceptionAction;
+ * type ExampleControllerMessenger = RestrictedMessenger<
+ *   'ExampleController',
+ *   AllowedActions,
+ *   never,
+ *   AllowedActions['type'],
+ *   never
+ * >;
+ *
+ * // Define the controller.
+ * class ExampleController extends BaseController<
+ *   'ExampleController',
+ *   ExampleControllerState,
+ *   ExampleControllerMessenger
+ * > {
+ *   doSomething() {
+ *     // Imagine that we do something that produces an error and we want to
+ *     // report the error.
+ *     this.messagingSystem.call(
+ *       'ErrorReportingService:captureException',
+ *       new Error('Something went wrong'),
+ *     );
+ *   }
+ * }
+ *
+ * // === Initialization file ===
+ *
+ * import { captureException } from '@sentry/browser';
+ * import { ErrorReportingService } from '@metamask/error-reporting-service';
+ * import { ExampleController } from './example-controller';
+ *
+ * // Create a global messenger.
+ * const globalMessenger = new Messenger();
+ *
+ * // Register handler for the `ErrorReportingService:captureException`
+ * // action in the global messenger.
+ * const errorReportingServiceMessenger = globalMessenger.getRestricted({
+ *   allowedActions: [],
+ *   allowedEvents: [],
+ * });
+ * const errorReportingService = new ErrorReportingService({
+ *   messenger: errorReportingServiceMessenger,
+ *   captureException,
+ * });
+ *
+ * const exampleControllerMessenger = globalMessenger.getRestricted({
+ *   allowedActions: ['ErrorReportingService:captureException'],
+ *   allowedEvents: [],
+ * });
+ * const exampleController = new ExampleController({
+ *   messenger: exampleControllerMessenger,
+ * });
+ *
+ * // === Somewhere else ===
+ *
+ * // Now this will report an error without throwing it.
+ * exampleController.doSomething();
+ * ```
+ */
+export class ErrorReportingService {
+    /**
+     * Constructs a new ErrorReportingService.
+     *
+     * @param options - The options.
+     * @param options.messenger - The messenger suited to this
+     * ErrorReportingService.
+     * @param options.captureException - A function that stores the given error in
+     * the error reporting service.
+     */
+    constructor({ messenger, captureException }) {
+        _ErrorReportingService_captureException.set(this, void 0);
+        _ErrorReportingService_messenger.set(this, void 0);
+        __classPrivateFieldSet(this, _ErrorReportingService_messenger, messenger, "f");
+        __classPrivateFieldSet(this, _ErrorReportingService_captureException, captureException, "f");
+        __classPrivateFieldGet(this, _ErrorReportingService_messenger, "f").registerActionHandler('ErrorReportingService:captureException', __classPrivateFieldGet(this, _ErrorReportingService_captureException, "f").bind(this));
+    }
+    /**
+     * Reports the given error to an external location.
+     *
+     * @param error - The error to report.
+     */
+    captureException(error) {
+        __classPrivateFieldGet(this, _ErrorReportingService_captureException, "f").call(this, error);
+    }
+}
+_ErrorReportingService_captureException = new WeakMap(), _ErrorReportingService_messenger = new WeakMap();
+//# sourceMappingURL=error-reporting-service.mjs.map

package/dist/error-reporting-service.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-reporting-service.mjs","sourceRoot":"","sources":["../src/error-reporting-service.ts"],"names":[],"mappings":";;;;;;;;;;;;AAuDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH,MAAM,OAAO,qBAAqB;IAKhC;;;;;;;;OAQG;IACH,YAAY,EAAE,SAAS,EAAE,gBAAgB,EAAgC;QAbhE,0DAAoE;QAEpE,mDAA2C;QAYlD,uBAAA,IAAI,oCAAc,SAAS,MAAA,CAAC;QAC5B,uBAAA,IAAI,2CAAqB,gBAAgB,MAAA,CAAC;QAE1C,uBAAA,IAAI,wCAAW,CAAC,qBAAqB,CACnC,wCAAwC,EACxC,uBAAA,IAAI,+CAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,CAClC,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACH,gBAAgB,CAAC,KAAY;QAC3B,uBAAA,IAAI,+CAAkB,MAAtB,IAAI,EAAmB,KAAK,CAAC,CAAC;IAChC,CAAC;CACF","sourcesContent":["import type { RestrictedMessenger } from '@metamask/base-controller';\n\n/**\n * The action which can be used to report an error.\n */\nexport type ErrorReportingServiceCaptureExceptionAction = {\n  type: 'ErrorReportingService:captureException';\n  handler: ErrorReportingService['captureException'];\n};\n\n/**\n * All actions that {@link ErrorReportingService} registers so that other\n * modules can call them.\n */\nexport type ErrorReportingServiceActions =\n  ErrorReportingServiceCaptureExceptionAction;\n\n/**\n * All events that {@link ErrorReportingService} publishes so that other modules\n * can subscribe to them.\n */\nexport type ErrorReportingServiceEvents = never;\n\n/**\n * All actions registered by other modules that {@link ErrorReportingService}\n * calls.\n */\ntype AllowedActions = never;\n\n/**\n * All events published by other modules that {@link ErrorReportingService}\n * subscribes to.\n */\ntype AllowedEvents = never;\n\n/**\n * The messenger restricted to actions and events that\n * {@link ErrorReportingService} needs to access.\n */\nexport type ErrorReportingServiceMessenger = RestrictedMessenger<\n  'ErrorReportingService',\n  ErrorReportingServiceActions | AllowedActions,\n  ErrorReportingServiceEvents | AllowedEvents,\n  AllowedActions['type'],\n  AllowedEvents['type']\n>;\n\n/**\n * The options that {@link ErrorReportingService} takes.\n */\ntype ErrorReportingServiceOptions = {\n  captureException: (error: unknown) => string;\n  messenger: ErrorReportingServiceMessenger;\n};\n\n/**\n * `ErrorReportingService` is designed to log an error to an error reporting app\n * such as Sentry, but in an agnostic fashion.\n *\n * @example\n *\n * In this example, we have a controller, and something bad happens, but we want\n * to report an error instead of throwing it.\n *\n * ``` ts\n * // === Controller file ===\n *\n * import type { ErrorReportingServiceCaptureExceptionAction } from '@metamask/error-reporting-service';\n *\n * // Define the messenger type for the controller.\n * type AllowedActions = ErrorReportingServiceCaptureExceptionAction;\n * type ExampleControllerMessenger = RestrictedMessenger<\n *   'ExampleController',\n *   AllowedActions,\n *   never,\n *   AllowedActions['type'],\n *   never\n * >;\n *\n * // Define the controller.\n * class ExampleController extends BaseController<\n *   'ExampleController',\n *   ExampleControllerState,\n *   ExampleControllerMessenger\n * > {\n *   doSomething() {\n *     // Imagine that we do something that produces an error and we want to\n *     // report the error.\n *     this.messagingSystem.call(\n *       'ErrorReportingService:captureException',\n *       new Error('Something went wrong'),\n *     );\n *   }\n * }\n *\n * // === Initialization file ===\n *\n * import { captureException } from '@sentry/browser';\n * import { ErrorReportingService } from '@metamask/error-reporting-service';\n * import { ExampleController } from './example-controller';\n *\n * // Create a global messenger.\n * const globalMessenger = new Messenger();\n *\n * // Register handler for the `ErrorReportingService:captureException`\n * // action in the global messenger.\n * const errorReportingServiceMessenger = globalMessenger.getRestricted({\n *   allowedActions: [],\n *   allowedEvents: [],\n * });\n * const errorReportingService = new ErrorReportingService({\n *   messenger: errorReportingServiceMessenger,\n *   captureException,\n * });\n *\n * const exampleControllerMessenger = globalMessenger.getRestricted({\n *   allowedActions: ['ErrorReportingService:captureException'],\n *   allowedEvents: [],\n * });\n * const exampleController = new ExampleController({\n *   messenger: exampleControllerMessenger,\n * });\n *\n * // === Somewhere else ===\n *\n * // Now this will report an error without throwing it.\n * exampleController.doSomething();\n * ```\n */\nexport class ErrorReportingService {\n  readonly #captureException: ErrorReportingServiceOptions['captureException'];\n\n  readonly #messenger: ErrorReportingServiceMessenger;\n\n  /**\n   * Constructs a new ErrorReportingService.\n   *\n   * @param options - The options.\n   * @param options.messenger - The messenger suited to this\n   * ErrorReportingService.\n   * @param options.captureException - A function that stores the given error in\n   * the error reporting service.\n   */\n  constructor({ messenger, captureException }: ErrorReportingServiceOptions) {\n    this.#messenger = messenger;\n    this.#captureException = captureException;\n\n    this.#messenger.registerActionHandler(\n      'ErrorReportingService:captureException',\n      this.#captureException.bind(this),\n    );\n  }\n\n  /**\n   * Reports the given error to an external location.\n   *\n   * @param error - The error to report.\n   */\n  captureException(error: Error): void {\n    this.#captureException(error);\n  }\n}\n"]}

package/dist/index.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorReportingService = void 0;
+var error_reporting_service_1 = require("./error-reporting-service.cjs");
+Object.defineProperty(exports, "ErrorReportingService", { enumerable: true, get: function () { return error_reporting_service_1.ErrorReportingService; } });
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,yEAAkE;AAAzD,gIAAA,qBAAqB,OAAA","sourcesContent":["export { ErrorReportingService } from './error-reporting-service';\nexport type {\n  ErrorReportingServiceActions,\n  ErrorReportingServiceCaptureExceptionAction,\n  ErrorReportingServiceEvents,\n  ErrorReportingServiceMessenger,\n} from './error-reporting-service';\n"]}

package/dist/index.d.cts

@@ -0,0 +1,3 @@
+export { ErrorReportingService } from "./error-reporting-service.cjs";
+export type { ErrorReportingServiceActions, ErrorReportingServiceCaptureExceptionAction, ErrorReportingServiceEvents, ErrorReportingServiceMessenger, } from "./error-reporting-service.cjs";
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,sCAAkC;AAClE,YAAY,EACV,4BAA4B,EAC5B,2CAA2C,EAC3C,2BAA2B,EAC3B,8BAA8B,GAC/B,sCAAkC"}

package/dist/index.d.mts

@@ -0,0 +1,3 @@
+export { ErrorReportingService } from "./error-reporting-service.mjs";
+export type { ErrorReportingServiceActions, ErrorReportingServiceCaptureExceptionAction, ErrorReportingServiceEvents, ErrorReportingServiceMessenger, } from "./error-reporting-service.mjs";
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,sCAAkC;AAClE,YAAY,EACV,4BAA4B,EAC5B,2CAA2C,EAC3C,2BAA2B,EAC3B,8BAA8B,GAC/B,sCAAkC"}

package/dist/index.mjs

@@ -0,0 +1,2 @@
+export { ErrorReportingService } from "./error-reporting-service.mjs";
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,sCAAkC","sourcesContent":["export { ErrorReportingService } from './error-reporting-service';\nexport type {\n  ErrorReportingServiceActions,\n  ErrorReportingServiceCaptureExceptionAction,\n  ErrorReportingServiceEvents,\n  ErrorReportingServiceMessenger,\n} from './error-reporting-service';\n"]}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@metamask-previews/error-reporting-service",
+  "version": "0.0.0-preview-d0685d1",
+  "description": "Logs errors to an error reporting service such as Sentry",
+  "keywords": [
+    "MetaMask",
+    "Ethereum"
+  ],
+  "homepage": "https://github.com/MetaMask/core/tree/main/packages/error-reporting-service#readme",
+  "bugs": {
+    "url": "https://github.com/MetaMask/core/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MetaMask/core.git"
+  },
+  "license": "MIT",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.cts",
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "build": "ts-bridge --project tsconfig.build.json --verbose --clean --no-references",
+    "build:docs": "typedoc",
+    "changelog:update": "../../scripts/update-changelog.sh @metamask/error-reporting-service",
+    "changelog:validate": "../../scripts/validate-changelog.sh @metamask/error-reporting-service",
+    "publish:preview": "yarn npm publish --tag preview",
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest --reporters=jest-silent-reporter",
+    "test:clean": "NODE_OPTIONS=--experimental-vm-modules jest --clearCache",
+    "test:verbose": "NODE_OPTIONS=--experimental-vm-modules jest --verbose",
+    "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --watch",
+    "since-latest-release": "../../scripts/since-latest-release.sh"
+  },
+  "dependencies": {
+    "@metamask/base-controller": "^8.0.1"
+  },
+  "devDependencies": {
+    "@metamask/auto-changelog": "^3.4.4",
+    "@sentry/core": "^9.22.0",
+    "@types/jest": "^27.4.1",
+    "deepmerge": "^4.2.2",
+    "jest": "^27.5.1",
+    "ts-jest": "^27.1.4",
+    "typedoc": "^0.24.8",
+    "typedoc-plugin-missing-exports": "^2.0.0",
+    "typescript": "~5.2.2"
+  },
+  "engines": {
+    "node": "^18.18 || >=20"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}