import * as React from "react";import * as Cause from "effect/Cause";import * as Data from "effect/Data";import * as Exit from "effect/Exit";import * as Option from "effect/Option";import * as Schema from "effect/Schema"; export type FrontendErrorContext = {  readonly surface: string;  readonly action: string;  readonly message?: string;  readonly severity?: "error" | "warning";  readonly metadata?: Record<string, string | number | boolean | null | undefined>;}; export type FrontendErrorReporter = (error: unknown, context: FrontendErrorContext) => void; export type FrontendErrorCapturePayload = {  readonly exception: Error;  readonly causePretty: string | null;}; class FrontendHandledError extends Data.TaggedError("FrontendHandledError")<{  readonly cause: unknown;  readonly context: FrontendErrorContext;}> {} const MAX_FRONTEND_CAUSE_PRETTY_CHARS = 4_000; const ErrorMessage = Schema.Struct({ message: Schema.String });const decodeErrorMessage = Schema.decodeUnknownOption(ErrorMessage); const isRecord = (input: unknown): input is Record<string, unknown> =>  typeof input === "object" && input !== null; const truncateCausePretty = (pretty: string): string =>  pretty.length <= MAX_FRONTEND_CAUSE_PRETTY_CHARS    ? pretty    : `${pretty.slice(0, MAX_FRONTEND_CAUSE_PRETTY_CHARS)}\n[truncated ${pretty.length - MAX_FRONTEND_CAUSE_PRETTY_CHARS} chars]`; const formatUnknownForErrorMessage = (input: unknown): string => {  if (typeof input === "string") return input.length > 0 ? input : "(empty string)";  if (input === null || input === undefined) return String(input);  if (    typeof input === "number" ||    typeof input === "boolean" ||    typeof input === "bigint" ||    typeof input === "symbol"  ) {    return String(input);  }  // oxlint-disable-next-line executor/no-try-catch-or-throw -- boundary: stringify arbitrary unknown values for a Sentry error message; JSON.stringify throws on cycles  try {    const json = JSON.stringify(input);    if (json) return json;  } catch {    return Object.prototype.toString.call(input);  }  return Object.prototype.toString.call(input);}; const causeFromUnknown = (input: unknown): Cause.Cause<unknown> | null => {  if (Cause.isCause(input)) return input;  if (isRecord(input) && Cause.isCause(input.cause)) return input.cause;  return null;}; const errorFromCause = (cause: Cause.Cause<unknown>, pretty: string): Error => {  const squashed = Cause.squash(cause);  // oxlint-disable-next-line executor/no-instanceof-error -- boundary: deciding whether the squashed failure is already a Sentry-ready Error payload  if (squashed instanceof Error) return squashed;  const prettyError = Cause.prettyErrors(cause)[0];  if (prettyError) return prettyError;  // oxlint-disable-next-line executor/no-error-constructor -- boundary: Sentry needs an Error payload for Effect causes  return new Error(pretty.length > 0 ? pretty : "Effect cause contained no failures");}; export const frontendErrorCapturePayload = (input: unknown): FrontendErrorCapturePayload => {  const cause = causeFromUnknown(input);  if (cause !== null) {    const causePretty = truncateCausePretty(Cause.pretty(cause));    return {      exception: errorFromCause(cause, causePretty),      causePretty: causePretty.length > 0 ? causePretty : null,    };  }   // oxlint-disable-next-line executor/no-instanceof-error -- boundary: deciding whether the incoming unknown is already a Sentry-ready Error payload  if (input instanceof Error) {    return { exception: input, causePretty: null };  }   return {    // oxlint-disable-next-line executor/no-error-constructor -- boundary: Sentry needs an Error payload for non-Error frontend failures    exception: new Error(`Non-Error frontend exception: ${formatUnknownForErrorMessage(input)}`),    causePretty: null,  };}; const defaultFrontendErrorReporter: FrontendErrorReporter = (error, context) => {  if (typeof globalThis.reportError !== "function") return;  globalThis.reportError(new FrontendHandledError({ cause: error, context }));}; const FrontendErrorReporterContext = React.createContext<FrontendErrorReporter>(  defaultFrontendErrorReporter,); let currentFrontendErrorReporter = defaultFrontendErrorReporter; export const reportHandledFrontendError = (error: unknown, context: FrontendErrorContext): void => {  currentFrontendErrorReporter(error, context);}; export const FrontendErrorReporterProvider = (  props: React.PropsWithChildren<{ reporter?: FrontendErrorReporter }>,) => {  const reporter = props.reporter ?? defaultFrontendErrorReporter;  currentFrontendErrorReporter = reporter;  return (    <FrontendErrorReporterContext.Provider value={reporter}>      {props.children}    </FrontendErrorReporterContext.Provider>  );}; export const useReportHandledError = (): FrontendErrorReporter =>  React.useContext(FrontendErrorReporterContext); export const messageFromUnknown = (error: unknown, fallback: string): string =>  Option.match(decodeErrorMessage(error), {    onNone: () => (typeof error === "string" && error.length > 0 ? error : fallback),    onSome: ({ message }) => message,  }); export const messageFromExit = (exit: Exit.Exit<unknown, unknown>, fallback: string): string =>  Option.match(Option.flatMap(Exit.findErrorOption(exit), decodeErrorMessage), {    onNone: () => fallback,    onSome: ({ message }) => message,  }); export const reportExitFailure = (  report: FrontendErrorReporter,  exit: Exit.Exit<unknown, unknown>,  context: FrontendErrorContext,): void => {  if (!Exit.isFailure(exit)) return;  report(exit.cause, context);}; export const useErrorMessageFromExit = (): ((  exit: Exit.Exit<unknown, unknown>,  fallback: string,  context: Omit<FrontendErrorContext, "message"> & { readonly message?: string },) => string) => {  const report = useReportHandledError();  return React.useCallback(    (exit, fallback, context) => {      const message = messageFromExit(exit, fallback);      reportExitFailure(report, exit, { ...context, message: context.message ?? message });      return message;    },    [report],  );}; export const reportCauseFailure = (  report: FrontendErrorReporter,  cause: Cause.Cause<unknown>,  context: FrontendErrorContext,): void => {  report(cause, context);};