expo-release 2.0.0 → 2.2.0

package/dist/operate.d.ts

@@ -16,8 +16,10 @@ export type OperationInput = {
     preUpdate?: string;
     postUpdate?: string;
     updateExtraArgs?: string;
+    exportSourceMaps?: boolean;
     dryRun?: boolean;
     readPackageJson?: () => Promise<unknown>;
+    hasSourceMaps?: () => Promise<boolean>;
 };
 export type OperationResult = 'skipped' | 'ota' | 'native-build' | 'recovery';
 export declare function updateMessage(input: {

package/dist/run.d.ts

@@ -1,6 +1,10 @@
 export type CommandRunner = (command: string[]) => Promise<string>;
 export declare function easCommand(...args: string[]): string[];
 export declare function runCaptured(command: string[]): Promise<string>;
+export declare function describeFailure(command: string[], exitCode: number, output: {
+    stderr: string;
+    stdout: string;
+}): string;
 export declare function runInherited(command: string[]): Promise<string>;
 export declare function parseJson(output: string): unknown;
 export declare function getRecord(value: unknown, context: string): Record<string, unknown>;

package/dist/runtime/error-boundary.d.ts

@@ -0,0 +1,27 @@
+import { Component, type ErrorInfo, type ReactNode } from 'react';
+export interface ErrorBoundaryFallbackProps {
+    error: Error;
+    /** Clears the error and renders the children again. */
+    reset: () => void;
+}
+export interface ErrorBoundaryProps {
+    children?: ReactNode;
+    fallback: (props: ErrorBoundaryFallbackProps) => ReactNode;
+    /**
+     * Report the error here. Render errors never reach global handlers or
+     * error-tracking autocapture, so capture them explicitly.
+     */
+    onError?: (error: Error, info: ErrorInfo) => void;
+}
+interface ErrorBoundaryState {
+    error: Error | null;
+}
+/** Error boundary without UI: `fallback` renders the error screen. */
+export declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    state: ErrorBoundaryState;
+    static getDerivedStateFromError(error: unknown): ErrorBoundaryState;
+    componentDidCatch(error: unknown, info: ErrorInfo): void;
+    reset: () => void;
+    render(): ReactNode;
+}
+export {};

package/dist/runtime/index.d.ts

@@ -0,0 +1,3 @@
+export { ErrorBoundary, type ErrorBoundaryFallbackProps, type ErrorBoundaryProps } from './error-boundary';
+export { checkForOTAUpdate, type ReloadApp, type UseOTAUpdatesOptions, useOTAUpdates } from './ota';
+export { createPushNotifications, type KeyValueStorage, type NotificationListeners, type PushNotifications, type PushNotificationsOptions, usePushNotifications } from './push';

package/dist/runtime/index.js

@@ -0,0 +1,214 @@
+// src/runtime/error-boundary.ts
+import { Component } from "react";
+var toError = (value) => value instanceof Error ? value : new Error(String(value));
+
+class ErrorBoundary extends Component {
+  state = { error: null };
+  static getDerivedStateFromError(error) {
+    return { error: toError(error) };
+  }
+  componentDidCatch(error, info) {
+    this.props.onError?.(toError(error), info);
+  }
+  reset = () => {
+    this.setState({ error: null });
+  };
+  render() {
+    const { error } = this.state;
+    return error ? this.props.fallback({ error, reset: this.reset }) : this.props.children;
+  }
+}
+// src/runtime/ota.ts
+import * as Updates from "expo-updates";
+import { useEffect, useRef } from "react";
+async function checkForOTAUpdate(onUpdateReady) {
+  const update = await Updates.checkForUpdateAsync();
+  if (!update.isAvailable)
+    return false;
+  const result = await Updates.fetchUpdateAsync();
+  if (!result.isNew)
+    return false;
+  onUpdateReady(() => Updates.reloadAsync());
+  return true;
+}
+function useOTAUpdates(onUpdateReady, options = {}) {
+  const {
+    enabled = Updates.isEnabled && !(typeof __DEV__ !== "undefined" && __DEV__)
+  } = options;
+  const callbacks = useRef({ onUpdateReady, onError: options.onError });
+  callbacks.current = { onUpdateReady, onError: options.onError };
+  const checked = useRef(false);
+  useEffect(() => {
+    if (!enabled || checked.current)
+      return;
+    checked.current = true;
+    checkForOTAUpdate((reload) => callbacks.current.onUpdateReady(reload)).catch((error) => callbacks.current.onError?.(error));
+  }, [enabled]);
+}
+// src/runtime/push.ts
+import * as Device from "expo-device";
+import * as Notifications from "expo-notifications";
+import { useCallback, useEffect as useEffect2, useState } from "react";
+function createPushNotifications(options) {
+  const {
+    storage,
+    registerDevice,
+    confirm,
+    onUnavailable,
+    onError = (message, error) => console.error(message, error),
+    projectId,
+    storageKey = "@notifications_permission_asked"
+  } = options;
+  Notifications.setNotificationHandler({
+    handleNotification: async () => options.foregroundBehavior ?? {
+      shouldShowBanner: true,
+      shouldShowList: true,
+      shouldPlaySound: true,
+      shouldSetBadge: false
+    }
+  });
+  Notifications.setNotificationChannelAsync("default", options.androidChannel ?? {
+    name: "Default",
+    importance: Notifications.AndroidImportance.HIGH,
+    vibrationPattern: [0, 250, 250, 250]
+  }).catch((error) => onError("Failed to create the notification channel", error));
+  let pendingPrompt = null;
+  const getPermissionStatus = () => Notifications.getPermissionsAsync();
+  async function hasPrompted() {
+    try {
+      return await storage.getItem(storageKey) === "true";
+    } catch {
+      return false;
+    }
+  }
+  async function requestPermissions() {
+    if (!Device.isDevice) {
+      onUnavailable?.("not-a-device");
+      return false;
+    }
+    try {
+      const { granted } = await Notifications.requestPermissionsAsync();
+      if (!granted)
+        onUnavailable?.("denied");
+      return granted;
+    } catch (error) {
+      onError("Failed to request notification permissions", error);
+      return false;
+    }
+  }
+  async function getPushToken() {
+    if (!Device.isDevice)
+      return null;
+    try {
+      const token = await Notifications.getExpoPushTokenAsync(projectId ? { projectId } : undefined);
+      return token.data;
+    } catch (error) {
+      onError("Failed to get the Expo push token", error);
+      return null;
+    }
+  }
+  async function syncToken() {
+    if (!(await getPermissionStatus()).granted)
+      return false;
+    const token = await getPushToken();
+    if (!token)
+      return false;
+    try {
+      await registerDevice(token);
+      return true;
+    } catch (error) {
+      onError("Failed to register the push token", error);
+      return false;
+    }
+  }
+  async function runPrompt() {
+    if (await hasPrompted())
+      return false;
+    try {
+      await storage.setItem(storageKey, "true");
+    } catch (error) {
+      onError("Failed to remember the notification prompt", error);
+    }
+    if (confirm && !await confirm())
+      return false;
+    if (!await requestPermissions())
+      return false;
+    await syncToken();
+    return true;
+  }
+  return {
+    getPermissionStatus,
+    hasPrompted,
+    requestPermissions,
+    getPushToken,
+    syncToken,
+    prompt() {
+      pendingPrompt ??= runPrompt().catch((error) => {
+        onError("Failed to prompt for notifications", error);
+        return false;
+      }).finally(() => {
+        pendingPrompt = null;
+      });
+      return pendingPrompt;
+    },
+    async enable() {
+      if (!await requestPermissions())
+        return false;
+      await syncToken();
+      return true;
+    },
+    disable() {
+      return registerDevice(null);
+    },
+    listen({ onReceived, onResponse }) {
+      const subscriptions = [
+        onReceived && Notifications.addNotificationReceivedListener(onReceived),
+        onResponse && Notifications.addNotificationResponseReceivedListener(onResponse)
+      ];
+      const launchResponse = onResponse ? Notifications.getLastNotificationResponse() : null;
+      if (launchResponse)
+        onResponse?.(launchResponse);
+      return () => {
+        for (const subscription of subscriptions)
+          subscription?.remove();
+      };
+    }
+  };
+}
+function usePushNotifications(push, { enabled = false } = {}) {
+  const [permission, setPermission] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const refresh = useCallback(async () => {
+    setPermission(await push.getPermissionStatus());
+  }, [push]);
+  useEffect2(() => {
+    refresh();
+    if (enabled)
+      push.syncToken();
+  }, [push, enabled, refresh]);
+  const withLoading = useCallback((action) => async () => {
+    setIsLoading(true);
+    try {
+      return await action();
+    } finally {
+      await refresh();
+      setIsLoading(false);
+    }
+  }, [refresh]);
+  return {
+    permission,
+    isEnabled: enabled && permission?.granted === true,
+    isLoading,
+    prompt: withLoading(push.prompt),
+    enable: withLoading(push.enable),
+    disable: withLoading(push.disable),
+    refresh
+  };
+}
+export {
+  ErrorBoundary,
+  checkForOTAUpdate,
+  createPushNotifications,
+  useOTAUpdates,
+  usePushNotifications
+};

package/dist/runtime/ota.d.ts

@@ -0,0 +1,19 @@
+/** Restarts the app on the downloaded update. */
+export type ReloadApp = () => Promise<void>;
+/**
+ * Checks for an EAS update and downloads it. Calls `onUpdateReady` once a new
+ * update is on disk; show a "Restart" prompt there and call `reload` to apply.
+ * Returns whether a new update was downloaded.
+ */
+export declare function checkForOTAUpdate(onUpdateReady: (reload: ReloadApp) => void): Promise<boolean>;
+export interface UseOTAUpdatesOptions {
+    /** Defaults to off in development and wherever expo-updates is disabled (Expo Go). */
+    enabled?: boolean;
+    /** A failed check is retried on the next launch; defaults to ignoring it. */
+    onError?: (error: unknown) => void;
+}
+/**
+ * Checks for an update once per mount. The callbacks are read through refs, so
+ * an unstable toast function never re-runs the check or stacks prompts.
+ */
+export declare function useOTAUpdates(onUpdateReady: (reload: ReloadApp) => void, options?: UseOTAUpdatesOptions): void;

package/dist/runtime/push.d.ts

@@ -0,0 +1,70 @@
+import * as Notifications from 'expo-notifications';
+/** Async key-value store. AsyncStorage and expo-secure-store adapters fit. */
+export interface KeyValueStorage {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+}
+export interface PushNotificationsOptions {
+    /** Remembers that the one-time prompt ran. */
+    storage: KeyValueStorage;
+    /** Saves this device's Expo push token on your backend; `null` removes it. */
+    registerDevice: (token: string | null) => Promise<void>;
+    /**
+     * Explains push before the OS dialog. Resolve `true` to continue. Without
+     * it, `prompt()` goes straight to the OS dialog.
+     */
+    confirm?: () => Promise<boolean>;
+    /** Push is off: the app runs on a simulator or the user denied permission. */
+    onUnavailable?: (reason: 'not-a-device' | 'denied') => void;
+    onError?: (message: string, error: unknown) => void;
+    /** Defaults to what expo-notifications reads from the app config. */
+    projectId?: string;
+    /** Android channel `default`, needed for heads-up notifications. */
+    androidChannel?: Notifications.NotificationChannelInput;
+    /** How notifications show while the app is in the foreground. */
+    foregroundBehavior?: Notifications.NotificationBehavior;
+    storageKey?: string;
+}
+export interface NotificationListeners {
+    onReceived?: (notification: Notifications.Notification) => void;
+    /** Also called with the response that launched the app, if any. */
+    onResponse?: (response: Notifications.NotificationResponse) => void;
+}
+export type PushNotifications = ReturnType<typeof createPushNotifications>;
+/**
+ * expo-notifications behind one object: permission flow, Expo push token and
+ * device registration. Create it once at module level.
+ */
+export declare function createPushNotifications(options: PushNotificationsOptions): {
+    getPermissionStatus: () => Promise<Notifications.NotificationPermissionsStatus>;
+    hasPrompted: () => Promise<boolean>;
+    requestPermissions: () => Promise<boolean>;
+    getPushToken: () => Promise<string | null>;
+    syncToken: () => Promise<boolean>;
+    /**
+     * Asks for push once per install (after sign-in, say), then registers the
+     * token. Never throws; concurrent calls share one dialog.
+     */
+    prompt(): Promise<boolean>;
+    /** Turns push on from settings. Resolves whether it is on. */
+    enable(): Promise<boolean>;
+    /** Removes this device's token from your backend. */
+    disable(): Promise<void>;
+    /** Subscribes to notifications. Returns the unsubscribe function. */
+    listen({ onReceived, onResponse }: NotificationListeners): () => void;
+};
+/**
+ * Push state for a settings screen. `enabled` is the user's saved preference;
+ * while it is on, the token is re-registered on mount.
+ */
+export declare function usePushNotifications(push: PushNotifications, { enabled }?: {
+    enabled?: boolean;
+}): {
+    permission: Notifications.NotificationPermissionsStatus | null;
+    isEnabled: boolean;
+    isLoading: boolean;
+    prompt: () => Promise<boolean>;
+    enable: () => Promise<boolean>;
+    disable: () => Promise<void>;
+    refresh: () => Promise<void>;
+};

package/dist/source-maps.d.ts

@@ -0,0 +1,8 @@
+import type { ReleasePlatform } from './args';
+export declare const SOURCE_MAP_OUTPUT_DIR = "dist";
+export declare function expoCommand(...args: string[]): string[];
+export declare function sourceMapExportCommand(platform: ReleasePlatform): string[];
+export declare function sourceMapUpdateArgs(): string[];
+export declare function mergeUpdateArgs(extra: string[] | undefined, exportSourceMaps: boolean): string[];
+export declare function defaultHasSourceMaps(directory?: string): Promise<boolean>;
+export declare function assertSourceMaps(hasSourceMaps?: () => Promise<boolean>): Promise<void>;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "expo-release",
-	"version": "2.0.0",
-	"description": "Fingerprint-driven Expo EAS release: OTA update or native store build",
+	"version": "2.2.0",
+	"description": "Fingerprint-driven Expo EAS release: OTA update or native store build, plus app runtime helpers",
 	"type": "module",
 	"module": "./dist/index.js",
 	"main": "./dist/index.js",
@@ -39,25 +39,58 @@
 			"bun": "./src/index.ts",
 			"import": "./dist/index.js",
 			"default": "./dist/index.js"
+		},
+		"./runtime": {
+			"types": "./dist/runtime/index.d.ts",
+			"import": "./dist/runtime/index.js",
+			"default": "./dist/runtime/index.js"
 		}
 	},
 	"scripts": {
 		"build": "bun run build:js && bun run build:types",
-		"build:js": "bun build ./src/index.ts ./src/cli.ts --outdir ./dist --target bun --packages external",
+		"build:js": "bun build ./src/index.ts ./src/cli.ts --outdir ./dist --target bun --packages external && bun build ./src/runtime/index.ts --outdir ./dist/runtime --target browser --packages external",
 		"build:types": "tsgo -p tsconfig.build.json",
 		"prepublishOnly": "bun run build",
-		"publish:patch": "npm version patch && npm publish",
-		"publish:minor": "npm version minor && npm publish",
-		"publish:major": "npm version major && npm publish",
 		"test": "bun test",
 		"lint": "bun run typecheck && bun biome check",
 		"lint:write": "bun run typecheck && bun biome check --write",
-		"typecheck": "tsgo --noEmit"
+		"typecheck": "tsgo --noEmit && tsgo --noEmit -p tsconfig.runtime.json",
+		"verify:package": "node scripts/verify-package.mjs"
+	},
+	"peerDependencies": {
+		"expo-device": ">=55",
+		"expo-notifications": ">=55",
+		"expo-updates": ">=55",
+		"react": ">=19"
+	},
+	"peerDependenciesMeta": {
+		"expo-device": {
+			"optional": true
+		},
+		"expo-notifications": {
+			"optional": true
+		},
+		"expo-updates": {
+			"optional": true
+		},
+		"react": {
+			"optional": true
+		}
 	},
 	"devDependencies": {
 		"@biomejs/biome": "^2.4.6",
 		"@types/bun": "latest",
+		"@types/react": "~19.2.0",
 		"@typescript/native-preview": "^7.0.0-dev.20260306.1",
+		"expo-device": "~55.0.10",
+		"expo-notifications": "~55.0.14",
+		"expo-updates": "~55.0.16",
+		"react": "19.2.0",
 		"typescript": "^5.7.0"
-	}
+	},
+	"homepage": "https://github.com/HansKristoffer/expo-release#readme",
+	"bugs": {
+		"url": "https://github.com/HansKristoffer/expo-release/issues"
+	},
+	"packageManager": "bun@1.4.2"
 }

package/src/args.ts

@@ -31,6 +31,7 @@ export type ReleaseOptions = {
 	preUpdate?: string
 	postUpdate?: string
 	updateExtraArgs?: string
+	exportSourceMaps: boolean
 	group?: string
 	runtimeVersion?: string
 	message?: string
@@ -39,7 +40,7 @@ export type ReleaseOptions = {
 }
 
 export const USAGE =
-	'Usage: expo-release <release|decide|operate> --profile <profile> [--base <sha>] [--head <sha>] [--platform ios|android] [--impact-paths apps/expo/] [--operation deploy|force-native|retry-ota|republish|rollback-embedded] [--deploy-type none|ota|native] [--channel <channel>] [--environment <env>] [--group <id>] [--runtime-version <hash>] [--message <msg>] [--fingerprint <hash>] [--auto-submit true] [--pre-update <cmd>] [--post-update <cmd>] [--update-extra-args <args>] [--dry-run] [--ignore-expo-impact true]'
+	'Usage: expo-release <release|decide|operate> --profile <profile> [--base <sha>] [--head <sha>] [--platform ios|android] [--impact-paths apps/expo/] [--operation deploy|force-native|retry-ota|republish|rollback-embedded] [--deploy-type none|ota|native] [--channel <channel>] [--environment <env>] [--group <id>] [--runtime-version <hash>] [--message <msg>] [--fingerprint <hash>] [--auto-submit true] [--export-source-maps true] [--pre-update <cmd>] [--post-update <cmd>] [--update-extra-args <args>] [--dry-run] [--ignore-expo-impact true]'
 
 function fromEnv(env: NodeJS.ProcessEnv, name: string): string | undefined {
 	const value = env[name]?.trim()
@@ -156,6 +157,7 @@ export function parseReleaseOptions(
 		'pre-update'?: string
 		'post-update'?: string
 		'update-extra-args'?: string
+		'export-source-maps'?: string
 		group?: string
 		'runtime-version'?: string
 		message?: string
@@ -184,6 +186,7 @@ export function parseReleaseOptions(
 				'pre-update': { type: 'string' },
 				'post-update': { type: 'string' },
 				'update-extra-args': { type: 'string' },
+				'export-source-maps': { type: 'string' },
 				group: { type: 'string' },
 				'runtime-version': { type: 'string' },
 				message: { type: 'string' },
@@ -298,6 +301,13 @@ export function parseReleaseOptions(
 				fromEnv(env, 'EXPO_RELEASE_UPDATE_EXTRA_ARGS')
 			)
 		),
+		exportSourceMaps: parseBoolean(
+			firstDefined(
+				values['export-source-maps'],
+				fromEnv(env, 'EXPO_RELEASE_EXPORT_SOURCE_MAPS')
+			),
+			false
+		),
 		group,
 		runtimeVersion: optionalString(
 			firstDefined(

package/src/cli.ts

@@ -49,13 +49,20 @@ function toOperationInput(
 		preUpdate: options.preUpdate,
 		postUpdate: options.postUpdate,
 		updateExtraArgs: options.updateExtraArgs,
+		exportSourceMaps: options.exportSourceMaps,
 		dryRun: options.dryRun
 	}
 }
 
 async function main() {
 	const raw = Bun.argv.slice(2)
-	if (raw.length === 0 || raw[0] === '--help' || raw[0] === '-h') {
+	// The composite action passes everything through EXPO_RELEASE_* env vars and no argv.
+	const hasEnvCommand = Boolean(process.env.EXPO_RELEASE_COMMAND?.trim())
+	if (
+		(raw.length === 0 && !hasEnvCommand) ||
+		raw[0] === '--help' ||
+		raw[0] === '-h'
+	) {
 		process.stdout.write(`${USAGE}\n`)
 		return
 	}

package/src/operate.ts

@@ -7,6 +7,11 @@ import {
 	generateFingerprint,
 	runInherited
 } from './run'
+import {
+	assertSourceMaps,
+	mergeUpdateArgs,
+	sourceMapExportCommand
+} from './source-maps'
 
 export type { Operation }
 
@@ -25,8 +30,10 @@ export type OperationInput = {
 	preUpdate?: string
 	postUpdate?: string
 	updateExtraArgs?: string
+	exportSourceMaps?: boolean
 	dryRun?: boolean
 	readPackageJson?: () => Promise<unknown>
+	hasSourceMaps?: () => Promise<boolean>
 }
 
 export type OperationResult = 'skipped' | 'ota' | 'native-build' | 'recovery'
@@ -107,6 +114,12 @@ async function publishUpdate(
 	commandRunner: CommandRunner
 ) {
 	await requireEnvironmentIfNeeded(input)
+	if (input.exportSourceMaps) {
+		await commandRunner(sourceMapExportCommand(input.platform))
+		if (input.dryRun !== true) {
+			await assertSourceMaps(input.hasSourceMaps)
+		}
+	}
 	await runHook(input.preUpdate, commandRunner)
 	const command = easCommand(
 		'update',
@@ -121,7 +134,12 @@ async function publishUpdate(
 	if (input.environment) {
 		command.push('--environment', input.environment)
 	}
-	command.push(...extraUpdateArgs(input.updateExtraArgs))
+	command.push(
+		...mergeUpdateArgs(
+			extraUpdateArgs(input.updateExtraArgs),
+			input.exportSourceMaps === true
+		)
+	)
 	await commandRunner(command)
 	await runHook(input.postUpdate, commandRunner)
 }

package/src/run.ts

@@ -16,18 +16,47 @@ export async function runCaptured(command: string[]): Promise<string> {
 		child.exited
 	])
 	if (exitCode !== 0) {
-		throw new Error(
-			`Command failed (${command.join(' ')}):\n${stderr || stdout}`
-		)
+		throw new Error(describeFailure(command, exitCode, { stderr, stdout }))
 	}
 	return stdout
 }
 
+const OUTPUT_TAIL_LINES = 100
+
+function tail(output: string): string {
+	const lines = output.trimEnd().split('\n')
+	if (lines.length <= OUTPUT_TAIL_LINES) return lines.join('\n')
+	const omitted = lines.length - OUTPUT_TAIL_LINES
+	return [
+		`... (${omitted} earlier lines omitted)`,
+		...lines.slice(-OUTPUT_TAIL_LINES)
+	].join('\n')
+}
+
+// Both streams are kept: EAS can print only an upgrade notice on stderr while
+// the real error lands on stdout (or the reverse). The command line holds no
+// secrets; tokens reach EAS through the environment, which is never printed.
+export function describeFailure(
+	command: string[],
+	exitCode: number,
+	output: { stderr: string; stdout: string }
+): string {
+	const sections = [
+		`Command failed with exit code ${exitCode}: ${quoteCommand(command)}`
+	]
+	if (output.stderr.trim()) sections.push(`stderr:\n${tail(output.stderr)}`)
+	if (output.stdout.trim()) sections.push(`stdout:\n${tail(output.stdout)}`)
+	if (sections.length === 1) sections.push('(no output)')
+	return sections.join('\n')
+}
+
 export async function runInherited(command: string[]): Promise<string> {
 	const child = Bun.spawn(command, { stdout: 'inherit', stderr: 'inherit' })
 	const exitCode = await child.exited
 	if (exitCode !== 0) {
-		throw new Error(`Command failed (${command.join(' ')})`)
+		throw new Error(
+			`Command failed with exit code ${exitCode}: ${quoteCommand(command)} (output above)`
+		)
 	}
 	return ''
 }

package/src/runtime/error-boundary.ts

@@ -0,0 +1,51 @@
+import { Component, type ErrorInfo, type ReactNode } from 'react'
+
+export interface ErrorBoundaryFallbackProps {
+	error: Error
+	/** Clears the error and renders the children again. */
+	reset: () => void
+}
+
+export interface ErrorBoundaryProps {
+	children?: ReactNode
+	fallback: (props: ErrorBoundaryFallbackProps) => ReactNode
+	/**
+	 * Report the error here. Render errors never reach global handlers or
+	 * error-tracking autocapture, so capture them explicitly.
+	 */
+	onError?: (error: Error, info: ErrorInfo) => void
+}
+
+interface ErrorBoundaryState {
+	error: Error | null
+}
+
+const toError = (value: unknown) =>
+	value instanceof Error ? value : new Error(String(value))
+
+/** Error boundary without UI: `fallback` renders the error screen. */
+export class ErrorBoundary extends Component<
+	ErrorBoundaryProps,
+	ErrorBoundaryState
+> {
+	override state: ErrorBoundaryState = { error: null }
+
+	static getDerivedStateFromError(error: unknown): ErrorBoundaryState {
+		return { error: toError(error) }
+	}
+
+	override componentDidCatch(error: unknown, info: ErrorInfo) {
+		this.props.onError?.(toError(error), info)
+	}
+
+	reset = () => {
+		this.setState({ error: null })
+	}
+
+	override render() {
+		const { error } = this.state
+		return error
+			? this.props.fallback({ error, reset: this.reset })
+			: this.props.children
+	}
+}