expo-release 2.3.1 → 2.4.0

package/dist/cli.js

@@ -2,18 +2,24 @@
 // @bun
 
 // src/cli.ts
-import { defineCli, defineCommand } from "hanzio/cli";
+import { relative } from "path";
+import {
+  CliUsageError,
+  defineCli,
+  defineCommand
+} from "hanzio/cli";
 
 // src/args.ts
 import { z } from "zod";
 var DEFAULT_IMPACT_PATHS = ["apps/expo/"];
 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 trimmed = (schema) => z.preprocess((value) => typeof value === "string" ? value.trim() : value, schema);
+var trueFalse = (env, fallback) => trimmed(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"),
+  base: text("BASE").describe("Git base SHA for the impact diff (default: the merge base on a pull request, else github.event.before)"),
+  head: text("HEAD").meta({ env: ["EXPO_RELEASE_HEAD", "GITHUB_SHA"] }).describe("Git head SHA for the impact diff"),
+  platform: trimmed(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)
@@ -24,16 +30,16 @@ var releaseFlags = z.object({
     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([
+  operation: trimmed(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+)"),
+  ])).default("deploy").meta({ env: "EXPO_RELEASE_OPERATION" }).describe("What to run"),
+  deployType: trimmed(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 eas.json profile channel, else the profile name)"),
+  environment: text("ENVIRONMENT").describe("EAS environment for eas update (required for Expo SDK 55+, where it defaults to the eas.json profile environment)"),
   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"),
@@ -43,7 +49,7 @@ var releaseFlags = z.object({
   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")
+  dryRun: z.preprocess((value) => typeof value === "string" && /^\s*(true|false)\s*$/.test(value) ? value.trim() === "true" : value, 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({
@@ -52,13 +58,13 @@ var releaseFlags = z.object({
       message: "required by --operation republish"
     });
 });
-function toReleaseOptions(command, { context: flags, env }) {
+function toReleaseOptions(command, { context: flags }, buildProfile = null) {
+  const environment = flags.environment ?? buildProfile?.environment;
   return {
     ...flags,
     command,
-    base: flags.base ?? env.GITHUB_EVENT_BEFORE,
-    head: flags.head ?? env.GITHUB_SHA,
-    channel: flags.channel ?? flags.profile
+    channel: flags.channel ?? buildProfile?.channel ?? flags.profile,
+    ...environment ? { environment } : {}
   };
 }
 function needsDecide(operation) {
@@ -102,22 +108,119 @@ ${delimiter}`;
 }
 
 // src/run.ts
+import { existsSync } from "fs";
+import { dirname, join } from "path";
 function easCommand(...args) {
   const bin = process.env.EAS_BIN?.trim();
-  return [bin && bin.length > 0 ? bin : "eas", ...args];
+  return [bin && bin.length > 0 ? bin : localBin("eas") ?? "eas", ...args];
 }
-async function runCaptured(command) {
-  const child = Bun.spawn(command, {
-    stdout: "pipe",
-    stderr: "pipe"
-  });
-  const [stdout, stderr, exitCode] = await Promise.all([
-    new Response(child.stdout).text(),
-    new Response(child.stderr).text(),
-    child.exited
+var localBins = new Map;
+function localBin(name) {
+  const cwd = process.cwd();
+  const cacheKey = `${cwd}\x00${name}`;
+  const cached = localBins.get(cacheKey);
+  if (cached !== undefined)
+    return cached;
+  let bin = null;
+  for (let dir = cwd;; dir = dirname(dir)) {
+    const candidate = join(dir, "node_modules", ".bin", name);
+    if (existsSync(candidate)) {
+      bin = candidate;
+      break;
+    }
+    if (existsSync(join(dir, ".git")) || dirname(dir) === dir)
+      break;
+  }
+  localBins.set(cacheKey, bin);
+  return bin;
+}
+
+class CommandError extends Error {
+  tail;
+  constructor(message, tail) {
+    super(message);
+    this.tail = tail;
+    this.name = "CommandError";
+  }
+}
+var ERROR_TAIL_LINES = 20;
+function lastLines(output, count = ERROR_TAIL_LINES) {
+  return output.split(`
+`).map((line) => line.trimEnd()).filter((line) => line.trim().length > 0).slice(-count);
+}
+var DRAIN_AFTER_EXIT_MS = 1000;
+function collect(stream, echo, sink) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder;
+  let text = "";
+  const done = (async () => {
+    try {
+      for (;; ) {
+        const { value, done } = await reader.read();
+        if (done)
+          break;
+        echo?.write(value);
+        const part = decoder.decode(value, { stream: true });
+        text += part;
+        sink.push(part);
+      }
+    } catch {}
+    const rest = decoder.decode();
+    sink.push(rest);
+    text += rest;
+  })();
+  return {
+    done,
+    stop: () => reader.cancel().catch(() => {
+      return;
+    }),
+    text: () => text
+  };
+}
+async function spawn(command, echoStdout, echoStderr = true) {
+  const child = Bun.spawn(command, { stdout: "pipe", stderr: "pipe" });
+  const combined = [];
+  const out = collect(child.stdout, echoStdout ? process.stdout : null, combined);
+  const err = collect(child.stderr, echoStderr ? process.stderr : null, combined);
+  const exitCode = await child.exited;
+  const drained = Promise.all([out.done, err.done]);
+  let timer;
+  const timedOut = await Promise.race([
+    drained.then(() => false),
+    new Promise((resolve) => {
+      timer = setTimeout(() => resolve(true), DRAIN_AFTER_EXIT_MS);
+    })
   ]);
+  clearTimeout(timer);
+  if (timedOut) {
+    await Promise.all([out.stop(), err.stop()]);
+    await drained;
+  }
+  return {
+    stdout: out.text(),
+    stderr: err.text(),
+    exitCode,
+    tail: lastLines(combined.join(""))
+  };
+}
+async function runCaptured(command) {
+  const { stdout, stderr, exitCode, tail } = await spawn(command, false);
+  if (exitCode !== 0) {
+    throw new CommandError(describeFailure(command, exitCode, { stderr, stdout }), tail);
+  }
+  return stdout;
+}
+async function runSilent(command) {
+  const { stdout, stderr, exitCode, tail } = await spawn(command, false, false);
   if (exitCode !== 0) {
-    throw new Error(describeFailure(command, exitCode, { stderr, stdout }));
+    throw new CommandError(describeFailure(command, exitCode, { stderr, stdout }), tail);
+  }
+  return stdout;
+}
+async function runInherited(command) {
+  const { stdout, exitCode, tail } = await spawn(command, true);
+  if (exitCode !== 0) {
+    throw new CommandError(`Command failed with exit code ${exitCode}: ${quoteCommand(command)} (output above)`, tail);
   }
   return stdout;
 }
@@ -150,21 +253,28 @@ ${tail(output.stdout)}`);
   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 with exit code ${exitCode}: ${quoteCommand(command)} (output above)`);
+function parseJsonDocument(output) {
+  const starts = [0];
+  for (const match of output.matchAll(/\n(?=[[{])/g)) {
+    starts.push(match.index + 1);
+  }
+  for (const start of starts) {
+    try {
+      return {
+        value: JSON.parse(output.slice(start)),
+        preamble: output.slice(0, start).trim()
+      };
+    } catch {}
   }
-  return "";
+  throw new Error(`Expected JSON output, received:
+${tail(output)}`);
 }
 function parseJson(output) {
-  try {
-    return JSON.parse(output);
-  } catch {
-    throw new Error(`Expected JSON output, received:
-${output}`);
-  }
+  const { value, preamble } = parseJsonDocument(output);
+  if (preamble)
+    process.stderr.write(`${preamble}
+`);
+  return value;
 }
 function getRecord(value, context) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
@@ -173,7 +283,7 @@ function getRecord(value, context) {
   return value;
 }
 function parseFingerprintHash(output) {
-  const record = getRecord(parseJson(output), "EAS fingerprint");
+  const record = getRecord(parseJsonDocument(output).value, "EAS fingerprint");
   if (typeof record.hash !== "string" || record.hash.length === 0) {
     throw new Error("EAS fingerprint output did not contain a full hash");
   }
@@ -186,8 +296,85 @@ function dryRunCommand(command) {
   process.stderr.write(`[dry-run] ${quoteCommand(command)}
 `);
 }
-async function generateFingerprint(input, commandRunner) {
-  return parseFingerprintHash(await commandRunner(easCommand("fingerprint:generate", "--platform", input.platform, "--build-profile", input.profile, "--json", "--non-interactive")));
+
+class StageError extends Error {
+  stage;
+  tail;
+  constructor(stage, message, tail = []) {
+    super(message);
+    this.stage = stage;
+    this.tail = tail;
+    this.name = "StageError";
+  }
+}
+async function stage(name, run) {
+  const started = performance.now();
+  try {
+    return await run();
+  } catch (error) {
+    if (error instanceof StageError)
+      throw error;
+    throw new StageError(name, error instanceof Error ? error.message : String(error), error instanceof CommandError ? error.tail : []);
+  } finally {
+    const seconds = ((performance.now() - started) / 1000).toFixed(1);
+    process.stderr.write(`[expo-release] ${name}: ${seconds}s
+`);
+  }
+}
+async function generateFingerprint(input, commandRunner, explainConfig) {
+  const output = await commandRunner(easCommand("fingerprint:generate", "--platform", input.platform, "--build-profile", input.profile, "--json", "--non-interactive"));
+  const { preamble } = parseJsonDocument(output);
+  if (preamble) {
+    const reason = explainConfig ? await explainConfig() : "";
+    throw new CommandError([
+      "eas fingerprint:generate could not load the app config and fell back to a default one, so its fingerprint may not match what EAS builds.",
+      `eas-cli printed:
+${preamble}`,
+      reason && `expo config said:
+${reason}`
+    ].filter(Boolean).join(`
+`), lastLines(reason || preamble));
+  }
+  return parseFingerprintHash(output);
+}
+
+// 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];
+  const local = localBin("expo");
+  return local ? [local, ...args] : ["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/decide.ts
@@ -226,8 +413,8 @@ function normalizeBuildStatus(value) {
   return null;
 }
 function dashboardBuildUrl(record) {
-  const ownerName = nestedString(record, "app", "ownerAccount", "name");
-  const slug = nestedString(record, "app", "slug");
+  const ownerName = nestedString(record, "project", "ownerAccount", "name") ?? nestedString(record, "app", "ownerAccount", "name");
+  const slug = nestedString(record, "project", "slug") ?? nestedString(record, "app", "slug");
   if (typeof record.id !== "string" || !ownerName || !slug) {
     return;
   }
@@ -252,13 +439,17 @@ function parseBuildList(output) {
     }
     const buildUrl = dashboardBuildUrl(record);
     const fingerprint = nestedString(record, "fingerprint", "hash");
-    const runtimeVersion = nestedString(record, "runtime", "version");
+    const runtimeVersion = nestedString(record, "runtimeVersion") ?? nestedString(record, "runtime", "version");
+    const errorCode = nestedString(record, "error", "errorCode");
+    const errorMessage = nestedString(record, "error", "message");
+    const error = [errorCode, errorMessage].filter(Boolean).join(": ");
     builds.push({
       id: record.id,
       status,
       ...buildUrl ? { buildUrl } : {},
       ...fingerprint ? { fingerprint } : {},
-      ...runtimeVersion ? { runtimeVersion } : {}
+      ...runtimeVersion ? { runtimeVersion } : {},
+      ...error ? { error } : {}
     });
   }
   return builds;
@@ -275,26 +466,71 @@ function hasExpoImpact(paths, impactPaths = DEFAULT_IMPACT_PATHS) {
 function resolveBuildDecision(builds) {
   const finished = builds.find((build) => build.status === "finished");
   if (finished) {
-    return { deployType: "ota", nativeBuildPending: false, build: finished };
+    return {
+      deployType: "ota",
+      reason: "finished-build",
+      nativeBuildPending: false,
+      build: finished
+    };
   }
   const inProgress = builds.find((build) => ACTIVE_BUILD_STATUSES.includes(build.status));
   if (inProgress) {
     return {
       deployType: "ota",
+      reason: "build-in-progress",
       nativeBuildPending: true,
       build: inProgress
     };
   }
   const newest = builds[0];
   if (newest?.status === "errored") {
-    const location = newest.buildUrl ?? newest.id;
-    throw new Error(`The most recent native build for this fingerprint failed (${location}). Fix the failure or use --operation force-native to queue another build.`);
+    const lines = [
+      `The newest native build for this fingerprint failed on EAS${newest.error ? `: ${newest.error}` : ` (build ${newest.id})`}`,
+      newest.buildUrl,
+      "Fix it, then run the workflow with operation force-native."
+    ].filter((line) => Boolean(line));
+    throw new StageError("errored build", lines.join(`
+`), lines);
   }
-  return { deployType: "native", nativeBuildPending: false, build: null };
+  return {
+    deployType: "native",
+    reason: "no-build-for-fingerprint",
+    nativeBuildPending: false,
+    build: null
+  };
+}
+async function readPullRequestBase() {
+  const path = process.env.GITHUB_EVENT_PATH;
+  if (!path)
+    return;
+  try {
+    const event = await Bun.file(path).json();
+    const sha = event.pull_request?.base?.sha;
+    return typeof sha === "string" && sha ? sha : undefined;
+  } catch {
+    return;
+  }
+}
+async function defaultBase(head, commandRunner) {
+  const event = process.env.GITHUB_EVENT_NAME;
+  if (event === "pull_request" || event === "pull_request_target") {
+    const base = await readPullRequestBase();
+    if (base && head) {
+      try {
+        const mergeBase = (await commandRunner(["git", "merge-base", base, head])).trim();
+        if (mergeBase)
+          return mergeBase;
+      } catch {}
+    }
+    if (base)
+      return base;
+  }
+  return process.env.GITHUB_EVENT_BEFORE?.trim() || undefined;
 }
 async function getChangedFiles(input, commandRunner) {
   const head = input.head;
-  if (!input.base || !head || /^0+$/.test(input.base)) {
+  const base = input.base ?? await defaultBase(head, commandRunner);
+  if (!base || !head || /^0+$/.test(base)) {
     return { files: [], unreachable: true };
   }
   try {
@@ -304,7 +540,7 @@ async function getChangedFiles(input, commandRunner) {
       "diff.relative=false",
       "diff",
       "--name-only",
-      input.base,
+      base,
       head
     ]);
     return {
@@ -319,25 +555,95 @@ async function getChangedFiles(input, commandRunner) {
 async function getMatchingBuilds(input, fingerprint, commandRunner) {
   return parseBuildList(await commandRunner(easCommand("build:list", "--platform", input.platform, "--build-profile", input.profile, "--fingerprint-hash", fingerprint, "--limit", "20", "--json", "--non-interactive")));
 }
+function fingerprintSources(value) {
+  const sources = value?.sources;
+  const map = new Map;
+  if (!Array.isArray(sources))
+    return map;
+  for (const source of sources) {
+    const key = source.type === "contents" ? source.id : source.filePath ?? source.id;
+    if (typeof key === "string")
+      map.set(key, source.hash ?? null);
+  }
+  return map;
+}
+var MAX_DIFF_SOURCES = 30;
+function diffFingerprintSources(compare) {
+  const record = getRecord(compare, "EAS fingerprint:compare");
+  const before = fingerprintSources(record.fingerprint1);
+  const after = fingerprintSources(record.fingerprint2);
+  const lines = [];
+  for (const [key, hash] of after) {
+    if (!before.has(key))
+      lines.push(`added ${key}`);
+    else if (before.get(key) !== hash)
+      lines.push(`changed ${key}`);
+  }
+  for (const key of before.keys()) {
+    if (!after.has(key))
+      lines.push(`removed ${key}`);
+  }
+  if (lines.length <= MAX_DIFF_SOURCES)
+    return lines;
+  return [
+    ...lines.slice(0, MAX_DIFF_SOURCES),
+    `... and ${lines.length - MAX_DIFF_SOURCES} more`
+  ];
+}
+async function explainNativeDecision(input, commandRunner) {
+  try {
+    return await stage("fingerprint diff", async () => {
+      const [last] = parseBuildList(await commandRunner(easCommand("build:list", "--platform", input.platform, "--build-profile", input.profile, "--status", "finished", "--limit", "1", "--json", "--non-interactive")));
+      if (!last)
+        return null;
+      const command = easCommand("fingerprint:compare", "--build-id", last.id, "--json", "--non-interactive");
+      if (input.environment)
+        command.push("--environment", input.environment);
+      const { value } = parseJsonDocument(await commandRunner(command));
+      return {
+        buildId: last.id,
+        ...last.buildUrl ? { buildUrl: last.buildUrl } : {},
+        sources: diffFingerprintSources(value)
+      };
+    });
+  } catch (error) {
+    process.stderr.write(`Warning: could not compare the fingerprint with the last finished build: ${error instanceof Error ? error.message : String(error)}
+`);
+    return null;
+  }
+}
+async function explainConfigFailure(commandRunner) {
+  try {
+    await commandRunner(expoCommand("config", "--json"));
+    return "";
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+}
 async function decideRelease(input, commandRunner = runCaptured) {
-  const { files: changedFiles, unreachable } = await getChangedFiles(input, commandRunner);
+  const { files: changedFiles, unreachable } = await stage("diff", () => getChangedFiles(input, commandRunner));
   if (!input.ignoreExpoImpact && !unreachable && !hasExpoImpact(changedFiles, input.impactPaths)) {
     return {
       deployType: "none",
+      reason: "no-impact-path",
       nativeBuildPending: false,
       changedFiles,
       fingerprint: null,
       build: null
     };
   }
-  const fingerprint = await generateFingerprint(input, commandRunner);
-  const resolved = resolveBuildDecision(await getMatchingBuilds(input, fingerprint, commandRunner));
+  await input.preflight?.();
+  const fingerprint = await stage("fingerprint", () => generateFingerprint(input, commandRunner, () => explainConfigFailure(commandRunner)));
+  const builds = await stage("build list", () => getMatchingBuilds(input, fingerprint, commandRunner));
+  const resolved = resolveBuildDecision(builds);
   return {
     deployType: resolved.deployType,
+    reason: resolved.reason,
     nativeBuildPending: resolved.nativeBuildPending,
     changedFiles,
     fingerprint,
-    build: resolved.build
+    build: resolved.build,
+    ...resolved.deployType === "native" ? { fingerprintDiff: await explainNativeDecision(input, commandRunner) } : {}
   };
 }
 async function writeDecideGitHubOutput(decision) {
@@ -347,52 +653,22 @@ async function writeDecideGitHubOutput(decision) {
     changed: String(decision.deployType !== "none"),
     fingerprint: decision.fingerprint ?? "",
     build_id: decision.build?.id ?? "",
-    build_url: decision.build?.buildUrl ?? ""
+    build_url: decision.build?.buildUrl ?? "",
+    reason: decision.reason,
+    changed_sources: decision.fingerprintDiff?.sources.join(`
+`) ?? "",
+    compared_build_url: decision.fingerprintDiff?.buildUrl ?? decision.fingerprintDiff?.buildId ?? ""
   });
 }
 
-// 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");
+// src/operate.ts
+function splitArgs(value) {
+  const args = [];
+  for (const match of (value ?? "").matchAll(/"((?:\\.|[^"\\])*)"|'([^']*)'|(\S+)/g)) {
+    args.push(match[1]?.replace(/\\(.)/g, "$1") ?? match[2] ?? match[3] ?? "");
   }
   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) ?? [];
-}
 function updateMessage(input) {
   if (input.message)
     return input.message;
@@ -417,23 +693,25 @@ async function defaultReadPackageJson() {
     return null;
   return file.json();
 }
+async function readExpoSdkMajor(readPackageJson = defaultReadPackageJson) {
+  const pkg = await readPackageJson();
+  if (!pkg || typeof pkg !== "object")
+    return null;
+  const record = pkg;
+  return parseExpoSdkMajor(record.dependencies?.expo ?? record.devDependencies?.expo);
+}
 async function requireEnvironmentIfNeeded(input) {
   if (input.environment)
     return;
-  const pkg = await (input.readPackageJson ?? defaultReadPackageJson)();
-  if (!pkg || typeof pkg !== "object" || pkg === null)
-    return;
-  const record = pkg;
-  const version = record.dependencies?.expo ?? record.devDependencies?.expo;
-  const major = parseExpoSdkMajor(version);
+  const major = await readExpoSdkMajor(input.readPackageJson);
   if (major !== null && major >= 55) {
-    throw new Error("EAS Update requires --environment for Expo SDK 55+. Pass --environment <name>.");
+    throw new Error("EAS Update requires --environment for Expo SDK 55+. Pass --environment <name> or set build.<profile>.environment in eas.json.");
   }
 }
-async function runHook(command, commandRunner) {
+async function runHook(name, command, commandRunner) {
   if (!command)
     return;
-  await commandRunner(["bash", "-c", command]);
+  await stage(name, () => commandRunner(["bash", "-c", command]));
 }
 function mutatingRunner(commandRunner, dryRun) {
   return async (command) => {
@@ -447,33 +725,44 @@ 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 stage("ota export", async () => {
+      await commandRunner(sourceMapExportCommand(input.platform));
+      if (input.dryRun !== true) {
+        await assertSourceMaps(input.hasSourceMaps);
+      }
+    });
   }
-  await runHook(input.preUpdate, commandRunner);
+  await runHook("pre-update", 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(...mergeUpdateArgs(extraUpdateArgs(input.updateExtraArgs), input.exportSourceMaps === true));
-  await commandRunner(command);
-  await runHook(input.postUpdate, commandRunner);
+  command.push(...mergeUpdateArgs(splitArgs(input.updateExtraArgs), input.exportSourceMaps === true));
+  await stage("ota update", () => commandRunner(command));
+  await runHook("post-update", input.postUpdate, commandRunner);
 }
 async function queueNativeBuild(input, commandRunner) {
-  const command = easCommand("build", "--platform", input.platform, "--profile", input.profile, "--non-interactive", "--no-wait");
+  const command = easCommand("build", "--platform", input.platform, "--profile", input.profile, "--non-interactive", "--no-wait", "--json");
   if (input.autoSubmit) {
     command.push("--auto-submit");
   }
-  await commandRunner(command);
+  const output = await stage("native build", () => commandRunner(command));
+  try {
+    const queued = output.trim() ? parseBuildList(output)[0] : undefined;
+    if (queued)
+      input.onQueuedBuild?.(queued);
+  } catch (error) {
+    process.stderr.write(`Warning: could not read the queued build from eas build --json: ${error instanceof Error ? error.message : String(error)}
+`);
+  }
+  return "native-build";
 }
 async function resolveRuntimeVersion(input, commandRunner) {
   if (input.runtimeVersion)
     return input.runtimeVersion;
   if (input.fingerprint)
     return input.fingerprint;
-  return generateFingerprint(input, commandRunner);
+  return stage("fingerprint", () => generateFingerprint(input, commandRunner));
 }
 async function operateRelease(input, commandRunner = runInherited) {
   const execute = mutatingRunner(commandRunner, input.dryRun === true);
@@ -482,19 +771,19 @@ async function operateRelease(input, commandRunner = runInherited) {
       if (!input.group) {
         throw new Error("Usage: --operation republish requires --group <update-group-id>");
       }
+      const group = input.group;
       await requireEnvironmentIfNeeded(input);
-      await execute(easCommand("update:republish", "--group", input.group, "--platform", input.platform, "--message", updateMessage(input), "--non-interactive"));
+      await stage("recovery", () => execute(easCommand("update:republish", "--group", group, "--platform", input.platform, "--message", updateMessage(input), "--non-interactive")));
       return "recovery";
     }
     case "rollback-embedded": {
       await requireEnvironmentIfNeeded(input);
       const runtimeVersion = await resolveRuntimeVersion(input, commandRunner);
-      await execute(easCommand("update:roll-back-to-embedded", "--channel", input.channel, "--platform", input.platform, "--runtime-version", runtimeVersion, "--message", updateMessage(input), "--non-interactive"));
+      await stage("recovery", () => execute(easCommand("update:roll-back-to-embedded", "--channel", input.channel, "--platform", input.platform, "--runtime-version", runtimeVersion, "--message", updateMessage(input), "--non-interactive")));
       return "recovery";
     }
     case "force-native":
-      await queueNativeBuild(input, execute);
-      return "native-build";
+      return queueNativeBuild(input, execute);
     case "retry-ota":
       await publishUpdate(input, execute);
       return "ota";
@@ -509,8 +798,7 @@ async function operateRelease(input, commandRunner = runInherited) {
     case "none":
       return "skipped";
     case "native":
-      await queueNativeBuild(input, execute);
-      return "native-build";
+      return queueNativeBuild(input, execute);
     case "ota":
       await publishUpdate(input, execute);
       return "ota";
@@ -520,19 +808,355 @@ async function operateRelease(input, commandRunner = runInherited) {
     }
   }
 }
-async function writeOperateGitHubOutput(result) {
-  await appendGitHubOutput({ result });
+async function writeOperateGitHubOutput(result, queuedBuild) {
+  await appendGitHubOutput({
+    result,
+    queued_build_id: queuedBuild?.id ?? "",
+    queued_build_url: queuedBuild?.buildUrl ?? ""
+  });
+}
+
+// src/doctor.ts
+var CREDENTIAL_FILE = /\.(keystore|jks|p8|p12|mobileprovision)$/;
+async function tryRun(runner, command) {
+  try {
+    return { ok: true, output: await runner(command) };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function defaultReadFile(path) {
+  const file = Bun.file(path);
+  return await file.exists() ? file.text() : null;
+}
+function versionOf(output) {
+  return output.match(/(\d+\.\d+\.\d+)/)?.[1];
+}
+async function checkTools(input, runner, findings) {
+  const env = input.env ?? process.env;
+  const eas = await tryRun(runner, easCommand("--version"));
+  if (!eas.ok) {
+    findings.push({
+      level: "error",
+      message: "eas-cli did not run.",
+      fix: "Add eas-cli to the app devDependencies, or set it up with expo/expo-github-action."
+    });
+  } else {
+    const wanted = input.easJson?.cli?.version;
+    const actual = versionOf(eas.output);
+    if (wanted && actual && !Bun.semver.satisfies(actual, wanted)) {
+      findings.push({
+        level: "error",
+        message: `eas-cli ${actual} does not satisfy eas.json cli.version ${wanted}.`,
+        fix: `Pin eas-cli ${wanted} in the app devDependencies or the workflow.`
+      });
+    }
+  }
+  if (env.CI && !env.EXPO_TOKEN) {
+    findings.push({
+      level: "error",
+      message: "EXPO_TOKEN is not set.",
+      fix: "Add the EXPO_TOKEN secret (https://expo.dev/settings/access-tokens) and pass it to the job."
+    });
+  }
+  const bun = input.buildProfile?.bun;
+  const bunVersion = input.bunVersion ?? Bun.version;
+  if (bun && bun !== bunVersion) {
+    findings.push({
+      level: "error",
+      message: `This job runs Bun ${bunVersion}, the "${input.profile}" profile builds with Bun ${bun}. The fingerprint and lockfile can differ between them.`,
+      fix: `Use Bun ${bun} in CI, or set build.${input.profile}.bun to ${bunVersion}.`
+    });
+  }
+  const node = input.buildProfile?.node;
+  if (node) {
+    const actual = await tryRun(runner, ["node", "--version"]);
+    const version = actual.ok ? versionOf(actual.output) : undefined;
+    if (version && version !== node) {
+      findings.push({
+        level: "warning",
+        message: `This job runs Node ${version}, the "${input.profile}" profile builds with Node ${node}.`,
+        fix: `Use Node ${node} in CI (actions/setup-node).`
+      });
+    }
+  }
+}
+async function checkProfile(input, findings) {
+  if (!input.easJson) {
+    findings.push({
+      level: "error",
+      message: "No eas.json in the working directory.",
+      fix: "Set working-directory to the Expo app, or run `eas build:configure` there."
+    });
+    return;
+  }
+  if (!input.buildProfile) {
+    const names = Object.keys(input.easJson.build ?? {}).join(", ") || "none";
+    findings.push({
+      level: "error",
+      message: `eas.json has no build profile "${input.profile}" (profiles: ${names}).`
+    });
+    return;
+  }
+  if (!input.buildProfile.channel) {
+    findings.push({
+      level: "warning",
+      message: `Build profile "${input.profile}" has no channel, so its builds receive no EAS updates.`,
+      fix: `Set build.${input.profile}.channel in eas.json.`
+    });
+  }
+  if (input.autoSubmit && !input.easJson.submit?.[input.profile]) {
+    findings.push({
+      level: "warning",
+      message: `auto-submit is on, but eas.json has no submit.${input.profile}.`,
+      fix: input.platform === "ios" ? `Set submit.${input.profile}.ios.ascAppId.` : `Set submit.${input.profile}.android.serviceAccountKeyPath, pointing at a file from an EAS file secret.`
+    });
+  }
+  if (!input.environment) {
+    const major = await readExpoSdkMajor(input.readPackageJson);
+    if (major !== null && major >= 55) {
+      findings.push({
+        level: "error",
+        message: "Expo SDK 55+ needs an EAS environment for eas update.",
+        fix: `Set build.${input.profile}.environment in eas.json, or pass --environment.`
+      });
+    }
+  }
+}
+async function checkTrackedFiles(runner, findings, readFile) {
+  const listed = await tryRun(runner, ["git", "ls-files"]);
+  if (!listed.ok)
+    return;
+  const files = listed.output.split(`
+`).filter(Boolean);
+  const credentials = files.filter((file) => CREDENTIAL_FILE.test(file) && !/(^|\/)debug\.keystore$/.test(file));
+  for (const file of files) {
+    if (!file.endsWith(".json") || credentials.includes(file))
+      continue;
+    const text = await readFile(file);
+    if (text && text.length < 50000 && /"type"\s*:\s*"service_account"/.test(text)) {
+      credentials.push(file);
+    }
+  }
+  if (credentials.length > 0) {
+    findings.push({
+      level: "error",
+      message: `Credentials are committed: ${credentials.join(", ")}.`,
+      fix: "Remove them from git, rotate them, and keep them in EAS (`eas credentials`, EAS file secrets)."
+    });
+  }
+  const generated = files.filter((file) => /^\.expo\//.test(file) || /\.log$/.test(file));
+  if (generated.length > 0) {
+    findings.push({
+      level: "warning",
+      message: `Generated files are committed: ${generated.slice(0, 5).join(", ")}${generated.length > 5 ? `, and ${generated.length - 5} more` : ""}.`,
+      fix: "git rm --cached them and add .expo/ and *.log to .gitignore."
+    });
+  }
+  const nativeDirs = ["android", "ios"].filter((dir) => files.some((file) => file.startsWith(`${dir}/`)));
+  if (nativeDirs.length === 0)
+    return;
+  const ignore = await readFile(".fingerprintignore") ?? "";
+  const lines = ignore.split(`
+`).map((line) => line.trim().replace(/^\//, ""));
+  const hidden = nativeDirs.filter((dir) => lines.some((line) => [dir, `${dir}/`, `${dir}/*`, `${dir}/**`, `${dir}/**/*`].includes(line)));
+  if (hidden.length > 0) {
+    findings.push({
+      level: "error",
+      message: `${hidden.join(" and ")} are committed, and .fingerprintignore hides them: EAS builds the committed tree, but a change there never asks for a native build.`,
+      fix: "Either delete and gitignore the native folders (continuous native generation), or stop ignoring them in .fingerprintignore."
+    });
+  }
+  return nativeDirs;
+}
+async function checkAppConfig(runner, findings, nativeDirs) {
+  const config = await tryRun(runner, expoCommand("config", "--json"));
+  if (!config.ok) {
+    findings.push({
+      level: "error",
+      message: `The app config did not load:
+${config.error}`,
+      fix: "Run `npx expo config` in the app with the same environment variables."
+    });
+    return;
+  }
+  let parsed = {};
+  try {
+    parsed = JSON.parse(config.output);
+  } catch {
+    return;
+  }
+  const policy = parsed.runtimeVersion?.policy;
+  if (policy !== "fingerprint") {
+    findings.push({
+      level: "warning",
+      message: `runtimeVersion is ${JSON.stringify(parsed.runtimeVersion ?? null)}, not { policy: 'fingerprint' }: an OTA can reach a binary whose native code differs.`,
+      fix: "Set runtimeVersion: { policy: 'fingerprint' } in the app config."
+    });
+  }
+  if (nativeDirs.length > 0 && Array.isArray(parsed.plugins) && parsed.plugins.length > 0) {
+    findings.push({
+      level: "warning",
+      message: `${nativeDirs.join(" and ")} are committed while the app config has plugins: EAS builds the committed tree and never applies config plugin changes.`,
+      fix: "Delete and gitignore the native folders, or run `npx expo prebuild` and commit after every plugin change."
+    });
+  }
+}
+async function runDoctor(input, runner = runSilent) {
+  const findings = [];
+  const readFile = input.readFile ?? defaultReadFile;
+  await checkProfile(input, findings);
+  await checkTools(input, runner, findings);
+  const nativeDirs = await checkTrackedFiles(runner, findings, readFile) ?? [];
+  if (input.full)
+    await checkAppConfig(runner, findings, nativeDirs);
+  return findings;
+}
+function escapeAnnotation(text) {
+  return text.replaceAll("%", "%25").replaceAll("\r", "%0D").replaceAll(`
+`, "%0A");
+}
+function formatFindings(findings, options = {}) {
+  return findings.map((finding) => {
+    const level = options.asWarnings ? "warning" : finding.level;
+    const text = finding.fix ? `${finding.message}
+Fix: ${finding.fix}` : finding.message;
+    return options.github ? `::${level} title=expo-release doctor::${escapeAnnotation(text)}` : `${level}: ${text}`;
+  }).join(`
+`);
+}
+
+// src/eas-json.ts
+async function readEasJson(path = "eas.json") {
+  const file = Bun.file(path);
+  if (!await file.exists())
+    return null;
+  const text = await file.text();
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch (error) {
+    const json5 = Bun.JSON5;
+    if (!json5)
+      throw error;
+    value = json5.parse(text);
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(`${path} must hold an object`);
+  }
+  return value;
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+}
+function merge(base, update) {
+  const result = { ...base, ...update };
+  for (const key of ["env", "ios", "android"]) {
+    const a = asRecord(base[key]);
+    const b = asRecord(update[key]);
+    if (a && b)
+      result[key] = key === "env" ? { ...a, ...b } : merge(a, b);
+  }
+  return result;
+}
+function resolveRaw(easJson, name, depth) {
+  if (depth >= 5) {
+    throw new Error('eas.json: too long a chain of "extends"; check the build profiles for a cycle');
+  }
+  const profile = asRecord(easJson.build?.[name]);
+  if (!profile) {
+    if (depth === 0)
+      return null;
+    throw new Error(`eas.json: build profile extends missing "${name}"`);
+  }
+  const { extends: parent, ...rest } = profile;
+  return typeof parent === "string" ? merge(resolveRaw(easJson, parent, depth + 1) ?? {}, rest) : rest;
+}
+function resolveBuildProfile(easJson, name, platform) {
+  const raw = resolveRaw(easJson, name, 0);
+  if (!raw)
+    return null;
+  const { ios, android, ...base } = raw;
+  const resolved = merge(base, asRecord(platform === "ios" ? ios : android) ?? {});
+  const text = (key) => typeof resolved[key] === "string" && resolved[key] !== "" ? resolved[key] : undefined;
+  const env = asRecord(resolved.env);
+  return {
+    channel: text("channel"),
+    environment: text("environment"),
+    node: text("node"),
+    bun: text("bun"),
+    ...env ? {
+      env: Object.fromEntries(Object.entries(env).map(([key, value]) => [key, String(value)]))
+    } : {}
+  };
+}
+function applyProfileEnv(profile, env = process.env) {
+  const applied = [];
+  for (const [key, value] of Object.entries(profile?.env ?? {})) {
+    if (env[key] !== undefined)
+      continue;
+    env[key] = value;
+    applied.push(key);
+  }
+  return applied;
 }
 
 // src/cli.ts
-function toDecisionInput(options) {
+var inGitHubActions = process.env.GITHUB_ACTIONS === "true";
+if (process.env.RUNNER_ENVIRONMENT === "self-hosted" && process.env.RUNNER_TEMP && !process.env.TMPDIR) {
+  process.env.TMPDIR = process.env.RUNNER_TEMP;
+}
+var current = null;
+async function prepare(command, ctx) {
+  const platform = ctx.context.platform;
+  const easJson = await readEasJson();
+  const buildProfile = easJson ? resolveBuildProfile(easJson, ctx.context.profile, platform) : null;
+  const applied = applyProfileEnv(buildProfile);
+  if (applied.length > 0) {
+    process.stderr.write(`[expo-release] env from eas.json build.${ctx.context.profile}: ${applied.join(", ")}
+`);
+  }
+  const sdk = await readExpoSdkMajor().catch(() => null);
+  const defaults = buildProfile && (sdk === null || sdk < 55) ? { ...buildProfile, environment: undefined } : buildProfile;
+  current = {
+    options: toReleaseOptions(command, ctx, defaults),
+    easJson,
+    buildProfile
+  };
+  return current;
+}
+function doctorInput(prepared, full) {
+  const { options } = prepared;
+  return {
+    profile: options.profile,
+    platform: options.platform,
+    environment: options.environment,
+    autoSubmit: options.autoSubmit,
+    easJson: prepared.easJson,
+    buildProfile: prepared.buildProfile,
+    full
+  };
+}
+function toDecisionInput(prepared) {
+  const { options } = prepared;
   return {
     base: options.base,
     head: options.head,
     profile: options.profile,
     platform: options.platform,
     impactPaths: options.impactPaths,
-    ignoreExpoImpact: shouldIgnoreExpoImpact(options)
+    ignoreExpoImpact: shouldIgnoreExpoImpact(options),
+    environment: options.environment,
+    preflight: async () => {
+      const findings = await runDoctor(doctorInput(prepared, false)).catch(() => []);
+      if (findings.length > 0) {
+        process.stderr.write(`${formatFindings(findings, { asWarnings: true, github: inGitHubActions })}
+`);
+      }
+    }
   };
 }
 function toOperationInput(options, decision) {
@@ -555,52 +1179,150 @@ function toOperationInput(options, decision) {
     dryRun: options.dryRun
   };
 }
-async function decide(options, ctx) {
-  const decision = await decideRelease(toDecisionInput(options));
+async function decide(prepared, ctx) {
+  const decision = await decideRelease(toDecisionInput(prepared));
   await writeDecideGitHubOutput(decision);
   ctx.stdout.write(`${JSON.stringify(decision)}
 `);
   return decision;
 }
 async function operate(options, decision, ctx) {
-  const result = await operateRelease(toOperationInput(options, decision));
-  await writeOperateGitHubOutput(result);
+  let queued;
+  const result = await operateRelease({
+    ...toOperationInput(options, decision),
+    onQueuedBuild: (build) => {
+      queued = build;
+    }
+  });
+  await writeOperateGitHubOutput(result, queued);
   ctx.stdout.write(`${result}
 `);
 }
-var COMMANDS = ["release", "decide", "operate"];
+function nextStep(stage, options) {
+  const app = relative(process.env.GITHUB_WORKSPACE ?? process.cwd(), process.cwd());
+  const from = app ? `From ${app}: ` : "";
+  const { platform, profile } = options;
+  switch (stage) {
+    case "doctor":
+      return "Fix the findings above; `expo-release doctor` runs the same checks.";
+    case "diff":
+      return "Check out with fetch-depth: 0 so both commits of the diff exist.";
+    case "fingerprint":
+      return `The app config or EAS project did not load. ${from}\`npx expo config\` and \`eas fingerprint:generate --platform ${platform} --build-profile ${profile}\` with the job's environment variables.`;
+    case "build list":
+    case "fingerprint diff":
+      return `Check that EXPO_TOKEN can read this project. ${from}\`eas build:list --platform ${platform} --build-profile ${profile}\`.`;
+    case "errored build":
+      return "Fix the build failure on EAS, then run the workflow with operation force-native.";
+    case "native build":
+      return `A native build that fails before it is queued usually needs one interactive run. ${from}\`eas credentials:configure-build --platform ${platform} --profile ${profile}\`.`;
+    case "ota export":
+    case "ota update":
+      return "Fix the bundle error above, then run the workflow with operation retry-ota.";
+    case "pre-update":
+    case "post-update":
+      return `The ${stage} command failed; it is the workflow's own step.`;
+    case "recovery":
+      return "Check the group or runtime version passed to the recovery operation.";
+    default: {
+      const _exhaustive = stage;
+      return _exhaustive;
+    }
+  }
+}
+function escapeData(text) {
+  return text.replaceAll("%", "%25").replaceAll("\r", "%0D").replaceAll(`
+`, "%0A");
+}
+function escapeProperty(text) {
+  return escapeData(text).replaceAll(":", "%3A").replaceAll(",", "%2C");
+}
+async function reportFailure(error, io) {
+  const stage = error instanceof StageError ? error.stage : undefined;
+  const options = current?.options;
+  const said = error instanceof StageError ? error.tail : [];
+  const next = stage && options ? nextStep(stage, options) : undefined;
+  io.stderr.write(`${error.message}
+`);
+  if (inGitHubActions) {
+    const where = options ? ` (${options.profile}, ${options.platform})` : "";
+    const title = `expo-release: ${stage ?? "release"} failed${where}`;
+    const message = said.slice(-3).join(`
+`) || error.message;
+    io.stderr.write(`::error title=${escapeProperty(title)}::${escapeData(message)}
+`);
+  }
+  await appendGitHubOutput({
+    result: "failed",
+    failed_stage: stage ?? "",
+    failure: [
+      said.length > 0 ? `EAS said:
+${said.join(`
+`)}` : error.message,
+      next ? `Next: ${next}` : ""
+    ].filter(Boolean).join(`
+`)
+  });
+}
 var cli = defineCli({
   name: "expo-release",
   description: "Fingerprint-driven Expo EAS release: OTA update or native store build",
   globals: releaseFlags,
   context: (flags) => flags,
+  defaultCommand: (env) => env.EXPO_RELEASE_COMMAND?.trim() || undefined,
+  onError: async (error, io) => {
+    if (error instanceof CliUsageError) {
+      if (error.kind === "missing-command" && process.argv.length <= 2) {
+        io.stdout.write(error.help);
+        return 0;
+      }
+      const code = io.print();
+      return code === 2 ? 1 : code;
+    }
+    if (error instanceof Error) {
+      await reportFailure(error, io);
+      return 1;
+    }
+    return io.print();
+  },
   commands: {
     release: defineCommand({
       description: "Run decide, then operate on its decision",
       run: async (_input, ctx) => {
-        const options = toReleaseOptions("release", ctx);
-        const decision = needsDecide(options.operation) ? await decide(options, ctx) : null;
-        await operate(options, decision, ctx);
+        const prepared = await prepare("release", ctx);
+        const decision = needsDecide(prepared.options.operation) ? await decide(prepared, ctx) : null;
+        await operate(prepared.options, decision, ctx);
       }
     }),
     decide: defineCommand({
-      description: "Print whether this change needs no deploy, an OTA update or a native build",
+      description: "Print whether this change needs no deploy, an OTA update or a native build, and why",
       run: async (_input, ctx) => {
-        await decide(toReleaseOptions("decide", ctx), ctx);
+        await decide(await prepare("decide", ctx), ctx);
       }
     }),
     operate: defineCommand({
       description: "Run --operation for --deploy-type",
       run: async (_input, ctx) => {
-        await operate(toReleaseOptions("operate", ctx), null, ctx);
+        await operate((await prepare("operate", ctx)).options, null, ctx);
+      }
+    }),
+    doctor: defineCommand({
+      description: "Check the EAS setup, the app config and the committed files; exit 1 on an error",
+      run: async (_input, ctx) => {
+        const prepared = await prepare("doctor", ctx);
+        const findings = await runDoctor(doctorInput(prepared, true));
+        if (findings.length === 0) {
+          ctx.stdout.write(`No problems found.
+`);
+          return;
+        }
+        ctx.stdout.write(`${formatFindings(findings, { github: inGitHubActions })}
+`);
+        if (findings.some((finding) => finding.level === "error")) {
+          throw new StageError("doctor", `${findings.filter((f) => f.level === "error").length} doctor check(s) failed.`);
+        }
       }
     })
   }
 });
-var env = Object.fromEntries(Object.entries(process.env).flatMap(([name, value]) => value?.trim() ? [[name, value.trim()]] : []));
-var argv = process.argv.slice(2);
-if (!argv.some((arg) => COMMANDS.includes(arg))) {
-  argv = env.EXPO_RELEASE_COMMAND ? [env.EXPO_RELEASE_COMMAND, ...argv] : argv.length === 0 ? ["--help"] : argv;
-}
-var code = await cli.run(argv, { env });
-process.exitCode = code === 2 ? 1 : code;
+process.exitCode = await cli.run();