expo-release 2.0.0 → 2.2.1

package/dist/index.js

@@ -1,60 +1,60 @@
 // @bun
 // src/args.ts
-import { parseArgs } from "util";
+import { z } from "zod";
 var DEFAULT_IMPACT_PATHS = ["apps/expo/"];
-var 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]";
-function fromEnv(env, name) {
-  const value = env[name]?.trim();
-  return value ? value : undefined;
-}
-function firstDefined(...values) {
-  return values.find((value) => value !== undefined && value.length > 0);
-}
-function optionalString(value) {
-  const trimmed = value?.trim();
-  return trimmed ? trimmed : undefined;
-}
-function parseImpactPaths(value) {
-  const paths = (value ?? DEFAULT_IMPACT_PATHS.join(",")).split(",").map((path) => path.trim()).filter(Boolean);
-  if (paths.length === 0) {
-    throw new Error("At least one --impact-paths entry is required");
-  }
-  return paths;
-}
-function parsePlatform(value) {
-  if (value === undefined || value === "ios")
-    return "ios";
-  if (value === "android")
-    return "android";
-  throw new Error("Usage: --platform ios|android");
-}
-function parseBoolean(value, fallback) {
-  if (value === undefined)
-    return fallback;
-  if (value === "true")
-    return true;
-  if (value === "false")
-    return false;
-  throw new Error(`Expected true or false, received: ${value}`);
-}
-function parseOperation(value) {
-  if (value === undefined || value === "deploy" || value === "force-native" || value === "retry-ota" || value === "republish" || value === "rollback-embedded") {
-    return value ?? "deploy";
-  }
-  throw new Error("Usage: --operation deploy|force-native|retry-ota|republish|rollback-embedded");
-}
-function parseDeployType(value) {
-  if (value === undefined || value === "none")
-    return "none";
-  if (value === "ota" || value === "native")
-    return value;
-  throw new Error("Usage: --deploy-type none|ota|native");
-}
-function parseCommandName(value) {
-  if (value === "release" || value === "decide" || value === "operate") {
-    return value;
-  }
-  throw new Error(USAGE);
+var text = (env) => z.string().transform((value) => value.trim() || undefined).optional().meta({ env: `EXPO_RELEASE_${env}` });
+var trueFalse = (env, fallback) => z.enum(["true", "false"]).default(fallback).transform((value) => value === "true").meta({ env: `EXPO_RELEASE_${env}` });
+var releaseFlags = z.object({
+  profile: z.string().trim().min(1).meta({ env: "EXPO_RELEASE_PROFILE" }).describe("EAS build profile, also the default update channel"),
+  base: text("BASE").describe("Git base SHA for the impact diff (falls back to GITHUB_EVENT_BEFORE)"),
+  head: text("HEAD").describe("Git head SHA for the impact diff (falls back to GITHUB_SHA)"),
+  platform: z.enum(["ios", "android"]).default("ios").meta({ env: "EXPO_RELEASE_PLATFORM" }).describe("Native platform"),
+  impactPaths: z.string().default(DEFAULT_IMPACT_PATHS.join(",")).transform((value, ctx) => {
+    const paths = value.split(",").map((path) => path.trim()).filter(Boolean);
+    if (paths.length === 0)
+      ctx.addIssue({
+        code: "custom",
+        message: "At least one --impact-paths entry is required"
+      });
+    return paths;
+  }).meta({ env: "EXPO_RELEASE_IMPACT_PATHS" }).describe("Comma-separated repo-root paths that count as an Expo change"),
+  ignoreExpoImpact: trueFalse("IGNORE_EXPO_IMPACT", "false").describe("Check the fingerprint even when no impact path changed"),
+  operation: z.enum([
+    "deploy",
+    "force-native",
+    "retry-ota",
+    "republish",
+    "rollback-embedded"
+  ]).default("deploy").meta({ env: "EXPO_RELEASE_OPERATION" }).describe("What to run"),
+  deployType: z.enum(["none", "ota", "native"]).default("none").meta({ env: "EXPO_RELEASE_DEPLOY_TYPE" }).describe("Decision type for operate"),
+  channel: text("CHANNEL").describe("EAS Update channel (default: the profile)"),
+  environment: text("ENVIRONMENT").describe("EAS environment for eas update (required for Expo SDK 55+)"),
+  autoSubmit: trueFalse("AUTO_SUBMIT", "true").describe("Pass --auto-submit on native builds"),
+  preUpdate: text("PRE_UPDATE").describe("Shell command run before eas update"),
+  postUpdate: text("POST_UPDATE").describe("Shell command run after a successful eas update"),
+  updateExtraArgs: text("UPDATE_EXTRA_ARGS").describe("Extra tokens appended to eas update"),
+  exportSourceMaps: trueFalse("EXPORT_SOURCE_MAPS", "false").describe("On OTA, expo export with external source maps, then publish dist"),
+  group: text("GROUP").describe("Update group ID for --operation republish"),
+  runtimeVersion: text("RUNTIME_VERSION").describe("Runtime version for rollback-embedded (default: the fingerprint)"),
+  message: text("MESSAGE").describe("Override the eas update message"),
+  fingerprint: text("FINGERPRINT").describe("Fingerprint hash to use instead of generating one"),
+  dryRun: z.boolean().meta({ env: "EXPO_RELEASE_DRY_RUN" }).describe("Print mutating EAS commands without running them")
+}).superRefine((flags, ctx) => {
+  if (flags.operation === "republish" && !flags.group)
+    ctx.addIssue({
+      code: "custom",
+      path: ["group"],
+      message: "required by --operation republish"
+    });
+});
+function toReleaseOptions(command, { context: flags, env }) {
+  return {
+    ...flags,
+    command,
+    base: flags.base ?? env.GITHUB_EVENT_BEFORE,
+    head: flags.head ?? env.GITHUB_SHA,
+    channel: flags.channel ?? flags.profile
+  };
 }
 function needsDecide(operation) {
   switch (operation) {
@@ -78,80 +78,6 @@ function shouldIgnoreExpoImpact(options) {
     return true;
   return process.env.GITHUB_EVENT_NAME === "workflow_dispatch" && options.operation === "deploy";
 }
-function parseReleaseOptions(args, env = process.env) {
-  let values;
-  let positionals;
-  try {
-    const parsed = parseArgs({
-      args,
-      allowPositionals: true,
-      strict: true,
-      options: {
-        profile: { type: "string" },
-        base: { type: "string" },
-        head: { type: "string" },
-        platform: { type: "string" },
-        "impact-paths": { type: "string" },
-        "ignore-expo-impact": { type: "string" },
-        operation: { type: "string" },
-        "deploy-type": { type: "string" },
-        channel: { type: "string" },
-        environment: { type: "string" },
-        "auto-submit": { type: "string" },
-        "pre-update": { type: "string" },
-        "post-update": { type: "string" },
-        "update-extra-args": { type: "string" },
-        group: { type: "string" },
-        "runtime-version": { type: "string" },
-        message: { type: "string" },
-        fingerprint: { type: "string" },
-        "dry-run": { type: "boolean", default: false }
-      }
-    });
-    values = parsed.values;
-    positionals = parsed.positionals;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`${USAGE}
-${message}`);
-  }
-  if (positionals.length > 1) {
-    throw new Error(USAGE);
-  }
-  const command = parseCommandName(positionals[0] ?? fromEnv(env, "EXPO_RELEASE_COMMAND"));
-  const profile = firstDefined(values.profile, fromEnv(env, "EXPO_RELEASE_PROFILE"));
-  if (!profile) {
-    throw new Error(USAGE);
-  }
-  const operation = parseOperation(firstDefined(values.operation, fromEnv(env, "EXPO_RELEASE_OPERATION")));
-  const group = optionalString(firstDefined(values.group, fromEnv(env, "EXPO_RELEASE_GROUP")));
-  if (operation === "republish" && !group) {
-    throw new Error("Usage: --operation republish requires --group <update-group-id>");
-  }
-  const channel = firstDefined(values.channel, fromEnv(env, "EXPO_RELEASE_CHANNEL")) ?? profile;
-  return {
-    command,
-    profile,
-    base: optionalString(firstDefined(values.base, fromEnv(env, "EXPO_RELEASE_BASE"), fromEnv(env, "GITHUB_EVENT_BEFORE"))),
-    head: optionalString(firstDefined(values.head, fromEnv(env, "EXPO_RELEASE_HEAD"), fromEnv(env, "GITHUB_SHA"))),
-    platform: parsePlatform(firstDefined(values.platform, fromEnv(env, "EXPO_RELEASE_PLATFORM"))),
-    impactPaths: parseImpactPaths(firstDefined(values["impact-paths"], fromEnv(env, "EXPO_RELEASE_IMPACT_PATHS"))),
-    ignoreExpoImpact: parseBoolean(firstDefined(values["ignore-expo-impact"], fromEnv(env, "EXPO_RELEASE_IGNORE_EXPO_IMPACT")), false),
-    operation,
-    deployType: parseDeployType(firstDefined(values["deploy-type"], fromEnv(env, "EXPO_RELEASE_DEPLOY_TYPE"))),
-    channel,
-    environment: optionalString(firstDefined(values.environment, fromEnv(env, "EXPO_RELEASE_ENVIRONMENT"))),
-    autoSubmit: parseBoolean(firstDefined(values["auto-submit"], fromEnv(env, "EXPO_RELEASE_AUTO_SUBMIT")), true),
-    preUpdate: optionalString(firstDefined(values["pre-update"], fromEnv(env, "EXPO_RELEASE_PRE_UPDATE"))),
-    postUpdate: optionalString(firstDefined(values["post-update"], fromEnv(env, "EXPO_RELEASE_POST_UPDATE"))),
-    updateExtraArgs: optionalString(firstDefined(values["update-extra-args"], fromEnv(env, "EXPO_RELEASE_UPDATE_EXTRA_ARGS"))),
-    group,
-    runtimeVersion: optionalString(firstDefined(values["runtime-version"], fromEnv(env, "EXPO_RELEASE_RUNTIME_VERSION"))),
-    message: optionalString(firstDefined(values.message, fromEnv(env, "EXPO_RELEASE_MESSAGE"))),
-    fingerprint: optionalString(firstDefined(values.fingerprint, fromEnv(env, "EXPO_RELEASE_FINGERPRINT"))),
-    dryRun: values["dry-run"] === true || parseBoolean(fromEnv(env, "EXPO_RELEASE_DRY_RUN"), false)
-  };
-}
 // src/github-output.ts
 import { appendFile } from "fs/promises";
 async function appendGitHubOutput(entries) {
@@ -185,16 +111,44 @@ async function runCaptured(command) {
     child.exited
   ]);
   if (exitCode !== 0) {
-    throw new Error(`Command failed (${command.join(" ")}):
-${stderr || stdout}`);
+    throw new Error(describeFailure(command, exitCode, { stderr, stdout }));
   }
   return stdout;
 }
+var OUTPUT_TAIL_LINES = 100;
+function tail(output) {
+  const lines = output.trimEnd().split(`
+`);
+  if (lines.length <= OUTPUT_TAIL_LINES)
+    return lines.join(`
+`);
+  const omitted = lines.length - OUTPUT_TAIL_LINES;
+  return [
+    `... (${omitted} earlier lines omitted)`,
+    ...lines.slice(-OUTPUT_TAIL_LINES)
+  ].join(`
+`);
+}
+function describeFailure(command, exitCode, output) {
+  const sections = [
+    `Command failed with exit code ${exitCode}: ${quoteCommand(command)}`
+  ];
+  if (output.stderr.trim())
+    sections.push(`stderr:
+${tail(output.stderr)}`);
+  if (output.stdout.trim())
+    sections.push(`stdout:
+${tail(output.stdout)}`);
+  if (sections.length === 1)
+    sections.push("(no output)");
+  return sections.join(`
+`);
+}
 async function runInherited(command) {
   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 "";
 }
@@ -390,6 +344,44 @@ async function writeDecideGitHubOutput(decision) {
     build_url: decision.build?.buildUrl ?? ""
   });
 }
+// src/source-maps.ts
+import { exists } from "fs/promises";
+var SOURCE_MAP_OUTPUT_DIR = "dist";
+function expoCommand(...args) {
+  const bin = process.env.EXPO_BIN?.trim();
+  if (bin && bin.length > 0)
+    return [bin, ...args];
+  return ["bunx", "expo", ...args];
+}
+function sourceMapExportCommand(platform) {
+  return expoCommand("export", "--platform", platform, "--output-dir", SOURCE_MAP_OUTPUT_DIR, "--source-maps", "external");
+}
+function mergeUpdateArgs(extra, exportSourceMaps) {
+  const args = extra ? [...extra] : [];
+  if (!exportSourceMaps)
+    return args;
+  if (!args.includes("--input-dir")) {
+    args.push("--input-dir", SOURCE_MAP_OUTPUT_DIR);
+  }
+  if (!args.includes("--skip-bundler")) {
+    args.push("--skip-bundler");
+  }
+  return args;
+}
+async function defaultHasSourceMaps(directory = SOURCE_MAP_OUTPUT_DIR) {
+  if (!await exists(directory))
+    return false;
+  for await (const _ of new Bun.Glob("**/*.map").scan(directory)) {
+    return true;
+  }
+  return false;
+}
+async function assertSourceMaps(hasSourceMaps = defaultHasSourceMaps) {
+  if (await hasSourceMaps())
+    return;
+  throw new Error("Expo export did not produce Hermes source maps in dist; refusing to publish an OTA update.");
+}
+
 // src/operate.ts
 function extraUpdateArgs(value) {
   return value?.split(/\s+/).filter(Boolean) ?? [];
@@ -447,12 +439,18 @@ function mutatingRunner(commandRunner, dryRun) {
 }
 async function publishUpdate(input, 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", "--channel", input.channel, "--platform", input.platform, "--message", updateMessage(input), "--non-interactive");
   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);
 }
@@ -519,7 +517,7 @@ async function writeOperateGitHubOutput(result) {
   await appendGitHubOutput({ result });
 }
 export {
-  operateRelease,
+  DEFAULT_IMPACT_PATHS,
   decideRelease,
-  DEFAULT_IMPACT_PATHS
+  operateRelease
 };

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;