@berachain/berajs 0.2.8-beta.9 → 0.2.10

package/dist/actions/governance/exports.d.ts

@@ -0,0 +1,140 @@
+import { AbiParameter, Address, PublicClient, AbiFunction, TransactionReceipt } from 'viem';
+import { ProposalErrorCodes, ProposalState } from '../../enum/governance/exports.js';
+import { ProposalStatus, ProposalSelectionFragment, Proposal_Filter, Proposal_OrderBy, OrderDirection, ProposalWithVotesFragment, GetProposalVotesQueryVariables, GetProposalVotesQuery } from '@berachain/graphql/governance';
+import { CustomProposal, GovernanceTopic, CustomProposalErrors } from '../../types/governance/exports.js';
+import graymatter from 'gray-matter';
+
+type CheckProposalFieldResultMinimal = ProposalErrorCodes | null;
+type CheckProposalFieldResult = ProposalErrorCodes | null | CheckProposalFieldResultMinimal[] | Record<string, CheckProposalFieldResultMinimal>;
+/**
+ * Validates a single proposal field or ABI-typed value.
+ * Returns `null` if valid, or a `ProposalErrorCodes` value describing the problem.
+ */
+declare function checkProposalField(arg: {
+    fieldOrType: "address" | "hex" | "abi" | "string" | "bool" | `uint${string}` | `int${string}` | "action" | "title" | "forumLink" | "description" | "logoURI" | "url";
+    value: unknown;
+    required?: boolean;
+    baseUrl?: string;
+    components?: readonly (AbiParameter | readonly AbiParameter[])[];
+}): CheckProposalFieldResultMinimal;
+/**
+ * For tuple/tuple[] types, may return nested error structures.
+ */
+declare function checkProposalField(arg: {
+    fieldOrType: "tuple[]" | "tuple";
+    value: unknown;
+    required?: boolean;
+    baseUrl?: string;
+    components?: readonly (AbiParameter | readonly AbiParameter[])[];
+}): CheckProposalFieldResult;
+
+declare const MOCKED_PROPOSAL_STATUSES: readonly ProposalStatus[];
+/**
+ * Derives the effective `ProposalStatus` by reconciling subgraph data with the
+ * on-chain contract state. Falls back to subgraph timestamps when the on-chain
+ * state is unavailable.
+ */
+declare function computeActualStatus(
+/** Subgraph proposal data */
+proposal: ProposalSelectionFragment, 
+/** Value returned by the `state` function of the governance contract */
+proposalOnChainState?: ProposalState): ProposalStatus;
+
+type GetAllProposalsArgs = BeraJS.BaseFunctionArgs & {
+    /** Subgraph filter applied to the proposals query */
+    where: Proposal_Filter;
+    /** Number of proposals to skip (for pagination) */
+    offset?: number;
+    /** Maximum proposals per page; must be ≤ 1000 */
+    perPage?: number;
+    orderBy?: Proposal_OrderBy;
+    orderDirection?: OrderDirection;
+    /** Full-text search query; switches to the search endpoint when provided */
+    text?: string;
+};
+/** Fetches a paginated list of governance proposals from the subgraph */
+declare function getAllProposals(_args: GetAllProposalsArgs): Promise<ProposalSelectionFragment[] | undefined>;
+
+interface GetBodyErrorsArgs {
+    /** The proposal to validate */
+    proposal: CustomProposal;
+    /** The current governance topic, used for forum link base URL validation */
+    currentTopic: GovernanceTopic;
+}
+/** Validates the body fields (title, description, forum link) of a proposal */
+declare function getBodyErrors({ proposal, currentTopic, }: GetBodyErrorsArgs): CustomProposalErrors;
+
+interface GetDecodedFunctionDataArgs {
+    /** Contract address that emitted the calldata */
+    address: Address;
+    /** Raw calldata to decode */
+    callData: `0x${string}`;
+    /** @default defaultChainId */
+    chainId?: number;
+    publicClient: PublicClient;
+}
+/**
+ * Decodes the function data from a given contract address and calldata.
+ *
+ * Attempts to decode using a known set of ABIs first, then falls back to
+ * fetching the ABI from the block-explorer API.
+ *
+ * @returns An object with the decoded ABI item, function signature, function name, and arguments.
+ */
+declare function getDecodedFunctionData({ address, callData, chainId, publicClient, }: GetDecodedFunctionDataArgs): Promise<{
+    args: never[];
+    abiItem?: undefined;
+    functionSignature?: undefined;
+    functionName?: undefined;
+} | {
+    abiItem: AbiFunction | undefined;
+    functionSignature: string | undefined;
+    functionName: string;
+    args: unknown[];
+}>;
+
+type GetProposalDetailsArgs = BeraJS.BaseFunctionArgs & {
+    /** On-chain proposal ID */
+    proposalId: string;
+    client?: PublicClient;
+};
+/** Fetches a single proposal with its vote data from the subgraph */
+declare function getProposalDetails(_args: GetProposalDetailsArgs): Promise<ProposalWithVotesFragment | undefined>;
+
+type GetProposalFromTxArgs = {
+    /** Viem public client used to fetch block and receipt data */
+    publicClient: PublicClient | undefined;
+} & ({
+    /** Pre-fetched transaction receipt */
+    tx: TransactionReceipt;
+} | {
+    /** Transaction hash to look up */
+    txHash: Address;
+});
+/**
+ * Reconstructs a `ProposalWithVotesFragment` from the `ProposalCreated` event
+ * emitted in a given transaction. Returns `null` if the event is not found.
+ */
+declare function getProposalFromTx(args: GetProposalFromTxArgs): Promise<ProposalWithVotesFragment | null>;
+
+type GetProposalVotesArgs = BeraJS.BaseFunctionArgs & {
+    /** GraphQL variables forwarded to the GetProposalVotes query */
+    variables: GetProposalVotesQueryVariables;
+};
+/** Fetches the votes for a proposal from the subgraph */
+declare function getProposalVotes(_args: GetProposalVotesArgs): Promise<{
+    data: GetProposalVotesQuery;
+}>;
+
+type ParseProposalBodyResult = graymatter.GrayMatterFile<string> & {
+    /** Whether the body uses YAML front-matter (true) or legacy heading format (false) */
+    isFrontMatter: boolean;
+};
+/**
+ * Parses the body of a governance proposal into structured front-matter and content.
+ * Supports YAML front-matter format and a legacy heading-based format.
+ * Falls back to raw description on parse failure.
+ */
+declare function parseProposalBody(proposal?: Pick<ProposalSelectionFragment, "description">): ParseProposalBodyResult;
+
+export { type GetAllProposalsArgs, type GetBodyErrorsArgs, type GetDecodedFunctionDataArgs, type GetProposalDetailsArgs, type GetProposalFromTxArgs, type GetProposalVotesArgs, MOCKED_PROPOSAL_STATUSES, type ParseProposalBodyResult, checkProposalField, computeActualStatus, getAllProposals, getBodyErrors, getDecodedFunctionData, getProposalDetails, getProposalFromTx, getProposalVotes, parseProposalBody };

package/dist/actions/governance/exports.mjs

@@ -0,0 +1,226 @@
+import {
+  checkProposalField,
+  getAllProposals,
+  getBodyErrors,
+  getProposalDetails,
+  getProposalFromTx,
+  getProposalVotes,
+  parseProposalBody
+} from "../../chunk-GUURQAME.mjs";
+import "../../chunk-DKMAIU74.mjs";
+import "../../chunk-GY6B3PD5.mjs";
+import "../../chunk-KHXJDYA4.mjs";
+
+// src/actions/governance/computeActualStatus.ts
+import {
+  ProposalStatus
+} from "@berachain/graphql/governance";
+var GOVERNANCE_ACCELERATE_PROPOSAL = false;
+var MOCKED_PROPOSAL_STATUSES = [
+  ProposalStatus.Active,
+  ProposalStatus.PendingQueue,
+  ProposalStatus.PendingExecution,
+  ProposalStatus.Defeated,
+  ProposalStatus.QuorumNotReached
+];
+function computeActualStatus(proposal, proposalOnChainState) {
+  const timestampInSeconds = Date.now() / 1e3;
+  if (proposalOnChainState !== void 0) {
+    if (proposal.status === ProposalStatus.CanceledByGuardian) {
+      return ProposalStatus.CanceledByGuardian;
+    }
+    if (proposalOnChainState === 2 /* Canceled */) {
+      if (Number(proposal.voteStartAt) < timestampInSeconds)
+        return ProposalStatus.CanceledByUser;
+      return ProposalStatus.CanceledByGuardian;
+    }
+    if (proposalOnChainState === 3 /* Defeated */) {
+      if (!proposal.pollResult) {
+        return ProposalStatus.QuorumNotReached;
+      }
+      if (
+        // Quorum might be null if no votes were cast.
+        !proposal.quorum || BigInt(proposal.quorum) > BigInt(proposal.pollResult.totalTowardsQuorum)
+      ) {
+        return ProposalStatus.QuorumNotReached;
+      }
+      return ProposalStatus.Defeated;
+    }
+    if (proposalOnChainState === 4 /* Succeeded */) {
+      return ProposalStatus.PendingQueue;
+    }
+    if (proposalOnChainState === 5 /* Queued */) {
+      if (Number(proposal.queueEnd) < Date.now() / 1e3) {
+        return ProposalStatus.PendingExecution;
+      }
+      return ProposalStatus.InQueue;
+    }
+    if (proposalOnChainState === 6 /* Expired */) {
+      console.warn("Unexpected expired state on proposal id: ", proposal.id);
+      return ProposalStatus.Defeated;
+    }
+  }
+  if (proposal.status === ProposalStatus.InQueue) {
+    if (Number(proposal.queueEnd) < Date.now() / 1e3) {
+      return ProposalStatus.PendingExecution;
+    }
+  }
+  if (GOVERNANCE_ACCELERATE_PROPOSAL && proposalOnChainState === 1 /* Active */ && proposal.quorum && BigInt(proposal.quorum) < BigInt(proposal.pollResult.totalTowardsQuorum) && Number(proposal.pollResult.forPercentage) > Number(proposal.pollResult.againstPercentage)) {
+    return ProposalStatus.PendingQueue;
+  }
+  if (proposal.status === ProposalStatus.Pending) {
+    if (Number(proposal.voteStartAt) < timestampInSeconds && Number(proposal.voteEndAt) > timestampInSeconds) {
+      return ProposalStatus.Active;
+    }
+    if (Number(proposal.voteEndAt) < timestampInSeconds) {
+      if (!proposal.pollResult) {
+        return ProposalStatus.QuorumNotReached;
+      }
+      if (!proposal.quorum || BigInt(proposal.quorum) > BigInt(proposal.pollResult.totalTowardsQuorum)) {
+        return ProposalStatus.QuorumNotReached;
+      }
+      if (proposal.pollResult?.against > proposal.pollResult?.for) {
+        return ProposalStatus.Defeated;
+      }
+      return ProposalStatus.PendingQueue;
+    }
+    return ProposalStatus.Pending;
+  }
+  if (proposal.status === ProposalStatus.Active && Number(proposal.voteEndAt) < timestampInSeconds) {
+    if (!proposal.quorum || BigInt(proposal.quorum) > BigInt(proposal.pollResult.totalTowardsQuorum)) {
+      return ProposalStatus.QuorumNotReached;
+    }
+    if (BigInt(proposal.pollResult?.against ?? 0n) > BigInt(proposal.pollResult?.for ?? 0n)) {
+      return ProposalStatus.Defeated;
+    }
+    return ProposalStatus.PendingQueue;
+  }
+  if (proposal.status === ProposalStatus.InQueue) {
+    if (Number(proposal.queueEnd) < Date.now() / 1e3) {
+      return ProposalStatus.PendingExecution;
+    }
+  }
+  return proposal.status;
+}
+
+// src/actions/governance/getDecodedFunctionData.ts
+import {
+  decodeFunctionData,
+  erc20Abi,
+  pad,
+  toFunctionSignature,
+  trim
+} from "viem";
+import { appConfig, defaultChainId } from "@berachain/config/internal";
+import { beraChefAbi } from "@berachain/abis/pol/rewards/beraChef";
+import { rewardVaultAbi } from "@berachain/abis/pol/rewards/rewardVault";
+function isProxyABI(abi) {
+  return abi.some((item) => {
+    const i = item;
+    return i.name === "implementation" || i.name === "proxyType" || i.type === "constructor" && i.inputs?.[0]?.name === "implementation";
+  });
+}
+async function _getAbi({
+  contractAddress,
+  chainId,
+  publicClient
+}) {
+  const url = `https://api.etherscan.io/v2/api?module=contract&action=getabi&address=${contractAddress}&apikey=${appConfig.apiKeys.private.etherscan}&chainId=${chainId}`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ABI: ${response.statusText}`);
+  }
+  const data = await response.json();
+  if (data.status === "0") throw new Error(data.result);
+  const abi = JSON.parse(data.result);
+  if (!isProxyABI(abi)) return abi;
+  const implementationResult = await publicClient.getStorageAt({
+    address: contractAddress,
+    // bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1)).
+    slot: "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc"
+  });
+  if (!implementationResult || trim(implementationResult) === "0x00")
+    return abi;
+  const implementationAddress = pad(trim(implementationResult), { size: 20 });
+  return _getAbi({
+    contractAddress: implementationAddress,
+    chainId,
+    publicClient
+  });
+}
+async function _getAbiForCallData({
+  address,
+  callData,
+  knownAbi,
+  chainId,
+  publicClient
+}) {
+  try {
+    if (decodeFunctionData({ data: callData, abi: knownAbi })) {
+      return knownAbi;
+    }
+  } catch {
+  }
+  return _getAbi({ contractAddress: address, chainId, publicClient }).catch(
+    () => void 0
+  );
+}
+function _decodeCallData(callData, abi) {
+  try {
+    return decodeFunctionData({ data: callData, abi });
+  } catch {
+    return void 0;
+  }
+}
+function _findAbiItem(abi, functionName) {
+  return abi.find(
+    (a) => a.type === "function" && a.name === functionName
+  );
+}
+function _getFunctionSignature(abiItem) {
+  if (!abiItem) return;
+  try {
+    return toFunctionSignature(abiItem);
+  } catch (error) {
+    console.error(error);
+  }
+}
+async function getDecodedFunctionData({
+  address,
+  callData,
+  chainId = defaultChainId,
+  publicClient
+}) {
+  const knownAbi = [...beraChefAbi, ...rewardVaultAbi, ...erc20Abi];
+  const abi = await _getAbiForCallData({
+    address,
+    callData,
+    knownAbi,
+    chainId,
+    publicClient
+  });
+  const decodedData = _decodeCallData(callData, abi);
+  if (!abi || !decodedData) {
+    return { args: [] };
+  }
+  const abiItem = _findAbiItem(abi, decodedData.functionName);
+  const functionSignature = _getFunctionSignature(abiItem);
+  return {
+    abiItem,
+    functionSignature,
+    functionName: decodedData.functionName,
+    args: decodedData.args
+  };
+}
+export {
+  MOCKED_PROPOSAL_STATUSES,
+  checkProposalField,
+  computeActualStatus,
+  getAllProposals,
+  getBodyErrors,
+  getDecodedFunctionData,
+  getProposalDetails,
+  getProposalFromTx,
+  getProposalVotes,
+  parseProposalBody
+};

package/dist/actions/server/exports.d.ts

@@ -0,0 +1,13 @@
+import { Address } from 'viem';
+import { GetValidatorBlockStatsQuery } from '@berachain/graphql/pol/subgraph';
+
+/**
+ * Server-only RSC variant. Goes directly to the pol subgraph upstream
+ * (no auth required) through the shared Apollo client factory.
+ */
+declare function getDailyValidatorBlockStats({ pubKey, first, ...args }: BeraJS.BaseFunctionArgs & {
+    pubKey: Address;
+    first?: number;
+}): Promise<GetValidatorBlockStatsQuery | undefined>;
+
+export { getDailyValidatorBlockStats };

package/dist/actions/server/exports.mjs

@@ -0,0 +1,27 @@
+import {
+  getApolloClient
+} from "../../chunk-3JJLQ2JX.mjs";
+import "../../chunk-DQRH5VE3.mjs";
+import "../../chunk-SZ5C44L5.mjs";
+import "../../chunk-ZLTMIFCZ.mjs";
+import "../../chunk-KHXJDYA4.mjs";
+
+// src/actions/server/getDailyValidatorBlockStats.ts
+import {
+  GetValidatorBlockStats
+} from "@berachain/graphql/pol/subgraph";
+async function getDailyValidatorBlockStats({
+  pubKey,
+  first = 1,
+  ...args
+}) {
+  const client = getApolloClient("pol.subgraph", args);
+  const result = await client.query({
+    query: GetValidatorBlockStats,
+    variables: { pubKey, first }
+  });
+  return result.data;
+}
+export {
+  getDailyValidatorBlockStats
+};

package/dist/chunk-3JJLQ2JX.mjs

@@ -0,0 +1,211 @@
+import {
+  parseBaseArgs
+} from "./chunk-DQRH5VE3.mjs";
+import {
+  BeraTracing
+} from "./chunk-SZ5C44L5.mjs";
+import {
+  RequestError
+} from "./chunk-ZLTMIFCZ.mjs";
+import {
+  BeraError
+} from "./chunk-KHXJDYA4.mjs";
+
+// src/actions/clients/BeraApolloClient.ts
+import {
+  ApolloClient,
+  ServerError
+} from "@apollo/client";
+import { appConfig } from "@berachain/config/internal";
+var BeraApolloClient = class extends ApolloClient {
+  /**
+   * The URL of the endpoint. Used for error reporting only.
+   */
+  url;
+  serviceName;
+  constructor(options) {
+    super(options);
+    this.url = options.url;
+    this.serviceName = options.name;
+  }
+  async query(options) {
+    const queryName = getQueryName(options.query);
+    const endpoint = {
+      url: this.url,
+      type: "graphql",
+      name: this.serviceName
+    };
+    const tags = {
+      "operation.type": "query",
+      "operation.source.name": endpoint.name,
+      "operation.source.url": endpoint.url,
+      "operation.source.type": endpoint.type,
+      "operation.source.queryName": queryName
+    };
+    try {
+      const executeQuery = () => super.query(
+        options
+      );
+      const res = await BeraTracing.startSpan(
+        {
+          name: `GraphQL ${queryName}`,
+          op: "BeraApolloClient.query",
+          attributes: tags
+        },
+        executeQuery
+      );
+      if (res.error || res.data === void 0) {
+        throw new BeraError({
+          level: "fatal",
+          tags,
+          message: "Bera Apollo Client: No data returned from query, but error should be thrown since errorPolicy is none"
+        });
+      }
+      return { data: res.data };
+    } catch (error) {
+      !appConfig.env.isProduction && console.error("BeraApolloClient error", error);
+      if (ServerError.is(error)) {
+        throw new RequestError({
+          // reason: error,
+          response: error.response,
+          cause: error,
+          statusCode: error.statusCode,
+          endpoint,
+          tags
+        });
+      }
+      if (error instanceof TypeError) {
+        throw new RequestError({
+          level: "fatal",
+          reason: "TypeError",
+          response: error,
+          cause: error,
+          endpoint,
+          tags
+        });
+      }
+      throw new RequestError({
+        response: error,
+        tags,
+        cause: error,
+        endpoint
+      });
+    }
+  }
+};
+function getQueryName(queryDefinition) {
+  const likelyNode = queryDefinition.definitions.find(
+    (def) => def.kind === "OperationDefinition"
+  );
+  return likelyNode?.name?.value;
+}
+
+// src/actions/clients/getApolloClient.ts
+import { InMemoryCache } from "@apollo/client";
+import { HttpLink } from "@apollo/client/link/http";
+import { getUriFromLink } from "@berachain/config";
+import { currentDapp, goldskyBaseUrl } from "@berachain/config/internal";
+import apiResults from "@berachain/graphql/dex/api";
+import { gql } from "@apollo/client";
+function applyStellateClientName(url) {
+  const headers = typeof url === "string" ? void 0 : url.headers;
+  const isDapp = !!currentDapp;
+  const isTest = process.env.VERCEL_ENV === "test";
+  const uri = getUriFromLink(url);
+  const name = typeof url === "string" ? "unknown" : url.name;
+  return {
+    uri,
+    name,
+    headers: {
+      ...headers,
+      "x-graphql-client-name": `berachain.${isDapp ? "dapps" : isTest ? "test" : (
+        // this tracks usage of the berajs package in other packages
+        "berajs"
+      )}`,
+      "x-graphql-client-version": `${process.env.VERCEL_TARGET_ENV}.${process.env.VERCEL_GIT_COMMIT_SHA}`
+    }
+  };
+}
+function getClient(endpoint, {
+  ssrMode,
+  inMemoryCacheOptions
+} = {}) {
+  const url = getUriFromLink(endpoint);
+  const headers = typeof endpoint === "string" ? void 0 : endpoint.headers;
+  let name = typeof endpoint === "string" ? void 0 : endpoint.name;
+  if (!name && url.includes(goldskyBaseUrl)) {
+    name = url.replace(goldskyBaseUrl, "").replace("/gn", "");
+  }
+  return new BeraApolloClient({
+    url,
+    name: name ?? "unknown",
+    link: new HttpLink({
+      uri: url,
+      headers
+    }),
+    defaultOptions: {
+      query: {
+        // With the default none error policy, an error causes the promise to reject.
+        errorPolicy: "none",
+        fetchPolicy: "no-cache"
+      }
+    },
+    cache: new InMemoryCache(inMemoryCacheOptions),
+    ssrMode
+  });
+}
+var SUBGRAPH_CLIENTS = [
+  "honey.subgraph",
+  "pol.subgraph"
+];
+function isSubgraphClient(name) {
+  return SUBGRAPH_CLIENTS.includes(name);
+}
+var clientCache = /* @__PURE__ */ new Map();
+function store(cacheKey, client) {
+  if (cacheKey) clientCache.set(cacheKey, client);
+  return client;
+}
+function getApolloClient(clientName, { ...args }) {
+  if (typeof window !== "undefined" && isSubgraphClient(clientName)) {
+    throw new BeraError({
+      message: "Subgraph Apollo client is server-only",
+      level: "error"
+    });
+  }
+  const { config, chainId } = parseBaseArgs(args);
+  const cacheKey = args.config ? null : `${chainId}:${clientName}`;
+  if (cacheKey) {
+    const cached = clientCache.get(cacheKey);
+    if (cached) return cached;
+  }
+  switch (clientName) {
+    case "api":
+      return store(
+        cacheKey,
+        getClient(applyStellateClientName(config.api), {
+          inMemoryCacheOptions: {
+            possibleTypes: apiResults.possibleTypes
+          }
+        })
+      );
+    case "bend.whisk":
+      if (!config.bend.whiskApi) {
+        throw new BeraError({
+          message: "Bend whisk API is not configured on this chain",
+          level: "error"
+        });
+      }
+      return store(cacheKey, getClient(config.bend.whiskApi));
+    case "honey.subgraph":
+      return store(cacheKey, getClient(config.honey.subgraph));
+    case "pol.subgraph":
+      return store(cacheKey, getClient(config.pol.subgraph));
+  }
+}
+
+export {
+  BeraApolloClient,
+  getApolloClient,
+  gql
+};

package/dist/chunk-7YVNSDXG.mjs

@@ -0,0 +1,86 @@
+import {
+  RequestError
+} from "./chunk-ZLTMIFCZ.mjs";
+import {
+  BeraError,
+  parseViemError
+} from "./chunk-KHXJDYA4.mjs";
+
+// src/errors/initBeraError.ts
+import { BaseError } from "viem";
+function initBeraError({
+  cause: error,
+  level
+}) {
+  if (error instanceof BaseError) {
+    const parsed = parseViemError({
+      error,
+      revertIfUnknown: false
+    });
+    if (parsed.isRequestError && parsed.rootCause instanceof BaseError && "url" in parsed.rootCause && typeof parsed.rootCause.url === "string") {
+      return new RequestError({
+        cause: parsed.rootCause,
+        response: void 0,
+        endpoint: {
+          url: parsed.rootCause.url,
+          type: "rpc"
+        },
+        level
+      });
+    }
+  }
+  const err = error instanceof BeraError ? error : new BeraError({
+    cause: error,
+    level
+  });
+  return err;
+}
+
+// src/utils/createEmitter.ts
+function createEmitter() {
+  const events = {};
+  return {
+    emit(event, ...args) {
+      for (const callback of events[event] || []) {
+        callback(...args);
+      }
+    },
+    events,
+    on(event, cb) {
+      if (!events[event]) {
+        events[event] = [];
+      }
+      events[event].push(cb);
+      return () => {
+        events[event] = events[event]?.filter((i) => cb !== i);
+      };
+    }
+  };
+}
+
+// src/errors/BeraMonitoring.ts
+var _emitter = createEmitter();
+var BeraMonitoring = {
+  /**
+   * Capture an exception. Notifies all subscribers.
+   */
+  captureException(exception) {
+    const event = {
+      exception,
+      timestamp: Date.now()
+    };
+    _emitter.emit("exception", event);
+  },
+  /**
+   * Subscribe to error events.
+   * @returns An unsubscribe function.
+   */
+  on(...args) {
+    return _emitter.on(...args);
+  }
+};
+
+export {
+  initBeraError,
+  BeraMonitoring
+};