@htgabriel/release-kit 0.1.0

package/dist/index.js

@@ -0,0 +1,1881 @@
+// src/exec/run.ts
+import crossSpawn from "cross-spawn";
+var ReleaseKitError = class extends Error {
+  code;
+  constructor(message, { code = 1 } = {}) {
+    super(message);
+    this.name = "ReleaseKitError";
+    this.code = code;
+  }
+};
+function fail(message, code = 1) {
+  throw new ReleaseKitError(message, { code });
+}
+function formatCommand(command, args, env = {}) {
+  const exported = Object.entries(env).filter(([key, value]) => value !== void 0 && (key === "APP_VARIANT" || key.startsWith("EAS_"))).map(([key, value]) => `${key}=${value}`).join(" ");
+  const body = [command, ...args].join(" ");
+  return exported ? `${exported} ${body}` : body;
+}
+var defaultRun = (command, args, { cwd, env, inherit = false, dryRun = false } = {}) => {
+  const extraEnv = env ?? {};
+  if (dryRun) {
+    return {
+      status: 0,
+      signal: null,
+      stdout: "",
+      stderr: "",
+      dryRun: true,
+      printed: formatCommand(command, args, extraEnv)
+    };
+  }
+  const result = crossSpawn.sync(command, args, {
+    cwd,
+    env: { ...process.env, ...extraEnv },
+    encoding: "utf8",
+    stdio: inherit ? "inherit" : "pipe",
+    maxBuffer: 32 * 1024 * 1024
+  });
+  return {
+    status: result.status ?? 1,
+    signal: result.signal ?? null,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    error: result.error
+  };
+};
+function requireSuccess(result, label) {
+  if (result.dryRun) return result;
+  if (result.status === 0) return result;
+  const how = result.signal ? `sinal ${result.signal}` : `exit ${result.status}`;
+  const detail = (result.stderr || result.stdout || result.error?.message || "").trim();
+  fail(`${label} falhou (${how}).${detail ? `
+${detail}` : ""}`);
+}
+
+// src/ui/log.ts
+import pc from "picocolors";
+function createLogger(options = {}) {
+  const write = options.write ?? ((line) => console.error(line));
+  const silent = Boolean(options.json);
+  const emit = (line) => {
+    if (silent) return;
+    write(line);
+  };
+  return {
+    info: (message) => emit(message),
+    warn: (message) => emit(pc.yellow(`! ${message}`)),
+    error: (message) => emit(pc.red(`\u2717 ${message}`)),
+    success: (message) => emit(pc.green(`\u2713 ${message}`)),
+    step: (message) => emit(pc.cyan(`\u2192 ${message}`)),
+    debug: (message) => {
+      if (!options.verbose) return;
+      emit(pc.dim(message));
+    }
+  };
+}
+
+// src/context.ts
+function createContext(overrides) {
+  const env = overrides.env ?? process.env;
+  const json = Boolean(overrides.json);
+  return {
+    repoRoot: overrides.repoRoot,
+    appDir: overrides.appDir ?? overrides.repoRoot,
+    releaseDir: overrides.releaseDir ?? `${overrides.repoRoot}/.release`,
+    env,
+    dryRun: Boolean(overrides.dryRun),
+    json,
+    verbose: Boolean(overrides.verbose),
+    nonInteractive: overrides.nonInteractive ?? !process.stdin.isTTY,
+    run: overrides.run ?? defaultRun,
+    log: overrides.log ?? createLogger({ json, verbose: overrides.verbose }),
+    confirm: overrides.confirm
+  };
+}
+
+// src/config/schema.ts
+import { z } from "zod";
+var platformSchema = z.enum(["android", "ios"]);
+var versionSourceSchema = z.enum(["app.json", "package.json"]);
+var gitPolicySchema = z.object({
+  releaseBranch: z.string().default("main"),
+  tagFormat: z.string().default("v{version}"),
+  requireClean: z.boolean().default(true),
+  requireSyncedWithRemote: z.boolean().default(true),
+  remote: z.string().default("origin")
+});
+var iosChannelSchema = z.object({
+  bundleId: z.string(),
+  ascAppId: z.string().optional(),
+  appleTeamId: z.string().optional(),
+  phasedRelease: z.boolean().default(false),
+  automaticRelease: z.boolean().default(false),
+  copyright: z.string().optional()
+});
+var androidChannelSchema = z.object({
+  package: z.string(),
+  testTrack: z.string().default("internal"),
+  productionTrack: z.string().default("production"),
+  initialRollout: z.number().min(0).max(1).default(1)
+});
+var otaSchema = z.object({
+  channel: z.string()
+});
+var channelSchema = z.object({
+  /** Canal protegido (produção): exige --i-know-this-is-production ou confirmação digitando a versão. */
+  protected: z.boolean().default(false),
+  /** Se false, o canal nunca envia à loja (ex: build local de sideload). */
+  store: z.boolean().default(true),
+  buildProfile: z.string(),
+  submitProfile: z.string().optional(),
+  /** Nome do "environment" do EAS (eas.json build.<profile>.environment) — usado nos checks de fingerprint/Sentry. */
+  easEnvironment: z.string().optional(),
+  /** Se o build profile já reusa o build number/versionCode (eas.json autoIncrement). */
+  autoIncrement: z.boolean().default(true),
+  /** Profiles com upload de sourcemap desligado (ex: SENTRY_DISABLE_AUTO_UPLOAD) não exigem token no doctor. */
+  sentryUploadDisabled: z.boolean().default(false),
+  env: z.record(z.string(), z.string()).default({}),
+  ios: iosChannelSchema.optional(),
+  android: androidChannelSchema.optional(),
+  ota: otaSchema.optional()
+});
+var toolchainBaselineSchema = z.object({
+  easCli: z.object({ min: z.string(), tested: z.string() }).optional(),
+  node: z.object({ min: z.string(), tested: z.string() }).optional(),
+  jdk: z.object({ min: z.string(), tested: z.string() }).optional(),
+  xcode: z.object({ min: z.string(), tested: z.string() }).optional(),
+  cocoapods: z.object({ min: z.string(), tested: z.string() }).optional()
+});
+var doctorConfigSchema = z.object({
+  sentry: z.boolean().default(false),
+  expoDoctor: z.boolean().default(true)
+});
+var releaseKitConfigSchema = z.object({
+  $schema: z.string().optional(),
+  appDir: z.string().default("."),
+  /** Conta/organização esperada no `eas whoami` (opcional; reforça o doctor). */
+  easOwner: z.string().optional(),
+  platforms: z.array(platformSchema).min(1),
+  locales: z.array(z.string()).min(1).default(["pt-BR"]),
+  notesDir: z.string().default("release-notes"),
+  version: z.object({ source: versionSourceSchema.default("app.json") }).default({ source: "app.json" }),
+  git: gitPolicySchema.default({}),
+  channels: z.record(z.string(), channelSchema).refine((channels) => Object.keys(channels).length > 0, {
+    message: 'defina ao menos um canal em "channels"'
+  }),
+  toolchain: toolchainBaselineSchema.default({}),
+  doctor: doctorConfigSchema.default({})
+});
+function parseConfig(input) {
+  return releaseKitConfigSchema.parse(input);
+}
+function channelOf(config, name) {
+  const channel = config.channels[name];
+  if (!channel) {
+    const available = Object.keys(config.channels).join(", ");
+    throw new Error(`canal desconhecido: "${name}". Canais dispon\xEDveis: ${available}`);
+  }
+  return channel;
+}
+function protectedChannelNames(config) {
+  return Object.entries(config.channels).filter(([, channel]) => channel.protected).map(([name]) => name);
+}
+
+// src/config/load.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { z as z2 } from "zod";
+var CONFIG_FILENAME = "release-kit.config.json";
+function configPath(repoRoot) {
+  return join(repoRoot, CONFIG_FILENAME);
+}
+function configExists(repoRoot) {
+  return existsSync(configPath(repoRoot));
+}
+function loadConfig(repoRoot) {
+  const path = configPath(repoRoot);
+  if (!existsSync(path)) {
+    fail(
+      `${CONFIG_FILENAME} n\xE3o encontrado em ${repoRoot}. Rode \`release-kit init\` para criar a configura\xE7\xE3o.`
+    );
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(path, "utf8"));
+  } catch (error) {
+    fail(`${CONFIG_FILENAME} n\xE3o \xE9 um JSON v\xE1lido: ${error.message}`);
+  }
+  try {
+    return parseConfig(raw);
+  } catch (error) {
+    if (error instanceof z2.ZodError) {
+      const issues = error.issues.map((issue) => `  - ${issue.path.join(".") || "(raiz)"}: ${issue.message}`);
+      fail(`${CONFIG_FILENAME} inv\xE1lido:
+${issues.join("\n")}`);
+    }
+    throw error;
+  }
+}
+function writeConfig(repoRoot, config) {
+  const path = configPath(repoRoot);
+  const withSchema = { $schema: "./node_modules/@htgabriel/release-kit/schema.json", ...config };
+  writeFileSync(path, `${JSON.stringify(withSchema, null, 2)}
+`);
+  return path;
+}
+
+// src/git/policy.ts
+function git(ctx, args, { allowFail = false } = {}) {
+  const result = ctx.run("git", args, { cwd: ctx.repoRoot, inherit: false });
+  if (!allowFail) requireSuccess(result, `git ${args.join(" ")}`);
+  return result;
+}
+function gitPorcelain(ctx) {
+  return git(ctx, ["status", "--porcelain"]).stdout;
+}
+function isWorkingTreeClean(ctx, ignoreDirs = [".release/"]) {
+  const dirty = gitPorcelain(ctx).split("\n").map((line) => line.trimEnd()).filter((line) => line.length > 0).filter((line) => !ignoreDirs.some((dir) => line.endsWith(` ${dir}`) || line.includes(` ${dir}`)));
+  return dirty.length === 0;
+}
+function dirtyFiles(ctx, ignoreDirs = [".release/"]) {
+  return gitPorcelain(ctx).split("\n").map((line) => line.trimEnd()).filter((line) => line.length > 0).filter((line) => !ignoreDirs.some((dir) => line.endsWith(` ${dir}`) || line.includes(` ${dir}`)));
+}
+function currentBranch(ctx) {
+  return git(ctx, ["rev-parse", "--abbrev-ref", "HEAD"]).stdout.trim();
+}
+function headSha(ctx) {
+  return git(ctx, ["rev-parse", "HEAD"]).stdout.trim();
+}
+function remoteSha(ctx, remote, branch) {
+  const result = git(ctx, ["rev-parse", `${remote}/${branch}`], { allowFail: true });
+  if (result.status !== 0) return null;
+  return result.stdout.trim();
+}
+function tagShaFormatted(ctx, tagFormat, version) {
+  const tag = renderTag(tagFormat, version);
+  const result = git(ctx, ["rev-parse", `${tag}^{commit}`], { allowFail: true });
+  if (result.status !== 0) return null;
+  return result.stdout.trim();
+}
+function lastTagMatching(ctx, tagFormat) {
+  const pattern = tagGlob(tagFormat);
+  const result = git(ctx, ["tag", "--list", pattern, "--sort=-creatordate"], { allowFail: true });
+  const [first] = (result.stdout || "").split("\n").map((line) => line.trim()).filter(Boolean);
+  return first ?? null;
+}
+function aheadBehind(ctx, remote, branch) {
+  const upstream = git(ctx, ["rev-parse", "--abbrev-ref", `${branch}@{upstream}`], { allowFail: true });
+  if (upstream.status !== 0) return null;
+  const counts = git(ctx, ["rev-list", "--left-right", "--count", `HEAD...${remote}/${branch}`], {
+    allowFail: true
+  });
+  if (counts.status !== 0) return null;
+  const [ahead = "0", behind = "0"] = counts.stdout.trim().split(/\s+/);
+  return { ahead: Number(ahead), behind: Number(behind) };
+}
+function renderTag(tagFormat, version) {
+  return tagFormat.replace("{version}", version);
+}
+function tagGlob(tagFormat) {
+  return tagFormat.replace("{version}", "*");
+}
+function checkGitPolicy(ctx, policy, { version, isProtectedChannel }) {
+  const checks = [];
+  const branch = currentBranch(ctx);
+  if (policy.requireClean) {
+    const dirty = dirtyFiles(ctx);
+    if (dirty.length) {
+      checks.push({ name: "git-clean", status: "fail", message: `working tree suja:
+${dirty.join("\n")}` });
+    } else {
+      checks.push({ name: "git-clean", status: "pass", message: "working tree limpa" });
+    }
+  }
+  if (isProtectedChannel) {
+    if (branch !== policy.releaseBranch) {
+      checks.push({
+        name: "git-branch",
+        status: "fail",
+        message: `canal protegido exige branch ${policy.releaseBranch} (atual: ${branch}).`
+      });
+    } else {
+      checks.push({ name: "git-branch", status: "pass", message: `branch ${branch}` });
+    }
+    const head = headSha(ctx);
+    const expectedTag = renderTag(policy.tagFormat, version);
+    const tagSha = tagShaFormatted(ctx, policy.tagFormat, version);
+    if (!tagSha) {
+      checks.push({ name: "git-tag", status: "fail", message: `tag ${expectedTag} n\xE3o existe (vers\xE3o atual: ${version}).` });
+    } else if (tagSha !== head) {
+      checks.push({
+        name: "git-tag",
+        status: "fail",
+        message: `tag ${expectedTag} (${tagSha.slice(0, 8)}) n\xE3o aponta para HEAD (${head.slice(0, 8)}).`
+      });
+    } else {
+      checks.push({ name: "git-tag", status: "pass", message: `${expectedTag} == HEAD` });
+    }
+    if (policy.requireSyncedWithRemote) {
+      const remote = remoteSha(ctx, policy.remote, policy.releaseBranch);
+      if (!remote) {
+        checks.push({
+          name: "git-sync",
+          status: "fail",
+          message: `${policy.remote}/${policy.releaseBranch} ausente. Rode git fetch ${policy.remote} ${policy.releaseBranch}.`
+        });
+      } else if (remote !== head) {
+        checks.push({
+          name: "git-sync",
+          status: "fail",
+          message: `HEAD (${head.slice(0, 8)}) \u2260 ${policy.remote}/${policy.releaseBranch} (${remote.slice(0, 8)}).`
+        });
+      } else {
+        checks.push({ name: "git-sync", status: "pass", message: `HEAD == ${policy.remote}/${policy.releaseBranch}` });
+      }
+    }
+    return checks;
+  }
+  if (policy.requireSyncedWithRemote) {
+    const status = aheadBehind(ctx, policy.remote, branch);
+    if (!status) {
+      checks.push({ name: "git-sync", status: "fail", message: `branch ${branch} sem upstream. Rode git push -u.` });
+    } else if (status.behind > 0) {
+      checks.push({ name: "git-sync", status: "fail", message: `branch atrasada ${status.behind} commit(s) em rela\xE7\xE3o ao upstream.` });
+    } else if (status.ahead > 0) {
+      checks.push({ name: "git-sync", status: "fail", message: `branch adiantada ${status.ahead} commit(s) \u2014 fa\xE7a push antes de buildar.` });
+    } else {
+      checks.push({ name: "git-sync", status: "pass", message: "sincronizada com o upstream" });
+    }
+  }
+  return checks;
+}
+
+// src/git/commits.ts
+var CONVENTIONAL_RE = /^(\w+)(?:\(([^)]+)\))?!?:\s*(.+)$/;
+function parseSubject(subject) {
+  const match = subject.match(CONVENTIONAL_RE);
+  if (!match) return { type: null, scope: null, description: subject };
+  const [, type, scope, description] = match;
+  return { type: type ?? null, scope: scope ?? null, description: description ?? subject };
+}
+function commitsSinceLastTag(ctx, tagFormat) {
+  const lastTag = lastTagMatching(ctx, tagFormat);
+  const range = lastTag ? `${lastTag}..HEAD` : "HEAD";
+  const result = git(ctx, ["log", range, "--pretty=format:%h %s"], { allowFail: true });
+  if (result.status !== 0) return [];
+  return result.stdout.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => {
+    const [sha, ...rest] = line.split(" ");
+    const subject = rest.join(" ");
+    const parsed = parseSubject(subject);
+    return { sha: sha ?? "", subject, ...parsed };
+  });
+}
+var USER_FACING_TYPES = /* @__PURE__ */ new Set(["feat", "fix"]);
+function userFacingCommits(commits) {
+  return commits.filter((commit) => commit.type && USER_FACING_TYPES.has(commit.type));
+}
+
+// src/project/version.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+import semver from "semver";
+function loadVersionFile(appDir, source) {
+  const path = join2(appDir, source);
+  if (!existsSync2(path)) fail(`${source} n\xE3o encontrado em ${appDir}.`);
+  const raw = readFileSync2(path, "utf8");
+  const json = JSON.parse(raw);
+  if (source === "app.json") {
+    return {
+      path,
+      json,
+      get: () => {
+        const expo = json.expo;
+        const version = expo?.version;
+        if (typeof version !== "string") fail(`app.json n\xE3o tem expo.version.`);
+        return version;
+      },
+      set: (next) => {
+        const expo = json.expo ?? {};
+        expo.version = next;
+        json.expo = expo;
+      }
+    };
+  }
+  return {
+    path,
+    json,
+    get: () => {
+      const version = json.version;
+      if (typeof version !== "string") fail(`package.json n\xE3o tem "version".`);
+      return version;
+    },
+    set: (next) => {
+      json.version = next;
+    }
+  };
+}
+function readAppVersion(appDir, config) {
+  return loadVersionFile(appDir, config.version.source).get();
+}
+function nextVersion(current, bump) {
+  if (bump === "patch" || bump === "minor" || bump === "major") {
+    const next = semver.inc(current, bump);
+    if (!next) fail(`n\xE3o foi poss\xEDvel incrementar "${bump}" a partir de ${current}.`);
+    return next;
+  }
+  if (!semver.valid(bump)) fail(`vers\xE3o inv\xE1lida: "${bump}". Use patch | minor | major | x.y.z.`);
+  if (semver.lte(bump, current)) {
+    fail(`${bump} n\xE3o \xE9 maior que a vers\xE3o atual (${current}).`);
+  }
+  return bump;
+}
+function writeAppVersion(appDir, config, next) {
+  const file = loadVersionFile(appDir, config.version.source);
+  file.set(next);
+  writeFileSync2(file.path, `${JSON.stringify(file.json, null, "	")}
+`);
+  return file.path;
+}
+
+// src/doctor/checks.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+
+// src/project/detect.ts
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
+var LOCKFILES = {
+  yarn: "yarn.lock",
+  pnpm: "pnpm-lock.yaml",
+  npm: "package-lock.json"
+};
+function detectPackageManager(repoRoot) {
+  for (const [pm, lockfile] of Object.entries(LOCKFILES)) {
+    if (existsSync3(join3(repoRoot, lockfile))) return pm;
+  }
+  return "npm";
+}
+function readEasJson(appDir) {
+  const path = join3(appDir, "eas.json");
+  if (!existsSync3(path)) return null;
+  try {
+    return JSON.parse(readFileSync3(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+// src/eas/cli.ts
+function eas(ctx, args, { inherit = false, env = {}, cwd } = {}) {
+  return ctx.run("eas", args, {
+    cwd: cwd ?? ctx.appDir,
+    env,
+    inherit,
+    dryRun: ctx.dryRun
+  });
+}
+function parseRemoteVersion(stdout) {
+  const text = String(stdout || "").trim();
+  const jsonStart = text.indexOf("{");
+  if (jsonStart === -1) return { versionCode: null, buildNumber: null, raw: text };
+  try {
+    const parsed = JSON.parse(text.slice(jsonStart));
+    return {
+      versionCode: parsed.versionCode != null ? String(parsed.versionCode) : null,
+      buildNumber: parsed.buildNumber != null ? String(parsed.buildNumber) : null,
+      raw: parsed
+    };
+  } catch {
+    return { versionCode: null, buildNumber: null, raw: text };
+  }
+}
+function projectRemoteVersion(ctx, { platform, buildProfile }) {
+  const args = ["build:version:get", "--non-interactive", "--json", "-e", buildProfile, "-p", platform];
+  const result = eas(ctx, args);
+  if (ctx.dryRun) return { versionCode: null, buildNumber: null, raw: null, dryRun: true };
+  requireSuccess(result, "eas build:version:get");
+  return parseRemoteVersion(result.stdout);
+}
+function expectedBuildNumber(current, { autoIncrement, platform }) {
+  const key = platform === "ios" ? "buildNumber" : "versionCode";
+  const currentValue = current[key];
+  if (!currentValue) return { key, current: null, expected: null };
+  if (!autoIncrement) return { key, current: currentValue, expected: currentValue };
+  const numeric = Number(currentValue);
+  if (!Number.isFinite(numeric)) return { key, current: currentValue, expected: null };
+  return { key, current: currentValue, expected: String(numeric + 1) };
+}
+function easWhoami(ctx) {
+  const result = eas(ctx, ["whoami"]);
+  if (ctx.dryRun) return { ok: true, account: null, raw: "[dry-run]" };
+  if (result.status !== 0) return { ok: false, account: null, raw: result.stderr || result.stdout };
+  const account = result.stdout.trim().split("\n").pop() ?? null;
+  return { ok: true, account, raw: result.stdout };
+}
+function easEnvList(ctx, environment) {
+  return eas(ctx, ["env:list", environment, "--format", "short"]);
+}
+function easEnvListHasKey(ctx, environment, key) {
+  const result = easEnvList(ctx, environment);
+  if (ctx.dryRun) return true;
+  if (result.status !== 0) return false;
+  const pattern = new RegExp(`(^|\\n)${key}(\\n|$)`);
+  return pattern.test(`${result.stdout}
+${result.stderr}`);
+}
+function easFingerprintGenerate(ctx, environment) {
+  return eas(ctx, ["fingerprint:generate", "--non-interactive", "--json", "--environment", environment]);
+}
+function easFingerprintCompare(ctx, environment, buildId) {
+  return eas(ctx, [
+    "fingerprint:compare",
+    "--non-interactive",
+    "--json",
+    "--build-id",
+    buildId,
+    "--environment",
+    environment
+  ]);
+}
+function easBuild(ctx, opts) {
+  const args = ["build", "-p", opts.platform, "--profile", opts.buildProfile, "--non-interactive"];
+  if (opts.local) args.push("--local");
+  if (opts.output) args.push("--output", opts.output);
+  return eas(ctx, args, { inherit: true, env: opts.env });
+}
+function easSubmit(ctx, opts) {
+  const args = ["submit", "-p", opts.platform, "--profile", opts.submitProfile, "--path", opts.path, "--non-interactive"];
+  return eas(ctx, args, { inherit: true, env: opts.env });
+}
+function easUpdate(ctx, opts) {
+  const args = ["update", "--channel", opts.channel, "--non-interactive"];
+  if (opts.message) args.push("--message", opts.message);
+  if (opts.platform) args.push("--platform", opts.platform);
+  return eas(ctx, args, { inherit: true, env: opts.env });
+}
+
+// src/doctor/toolchain.ts
+function parseVersion(input) {
+  const match = String(input ?? "").replace(/^v/i, "").match(/(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
+  if (!match) return null;
+  return { major: Number(match[1]), minor: Number(match[2] || 0), patch: Number(match[3] || 0) };
+}
+function cmpVersion(a, b) {
+  const pa = parseVersion(a);
+  const pb = parseVersion(b);
+  if (!pa || !pb) return 0;
+  if (pa.major !== pb.major) return pa.major - pb.major;
+  if (pa.minor !== pb.minor) return pa.minor - pb.minor;
+  return pa.patch - pb.patch;
+}
+function collectToolchain(ctx) {
+  const capture = (command, args, pick) => {
+    const result = ctx.run(command, args, { inherit: false });
+    if (result.status !== 0) return null;
+    return pick(`${result.stdout}
+${result.stderr}`);
+  };
+  const firstMatch = (text, re) => text.match(re)?.[1] ?? null;
+  return {
+    easCli: capture("eas", ["--version"], (t) => firstMatch(t, /eas-cli\/(\d+\.\d+\.\d+)/)),
+    node: capture("node", ["-v"], (t) => firstMatch(t, /v?(\d+\.\d+\.\d+)/)),
+    yarn: capture("yarn", ["-v"], (t) => firstMatch(t, /(\d+\.\d+\.\d+)/)),
+    jdk: capture("java", ["-version"], (t) => firstMatch(t, /version "(\d+(?:\.\d+\.\d+)?)/)),
+    xcode: capture("xcodebuild", ["-version"], (t) => firstMatch(t, /Xcode (\d+\.\d+)/)),
+    xcodeBuild: capture("xcodebuild", ["-version"], (t) => firstMatch(t, /Build version (\S+)/)),
+    cocoapods: capture("pod", ["--version"], (t) => firstMatch(t, /(\d+\.\d+\.\d+)/)),
+    ndkHome: ctx.env.ANDROID_NDK_HOME || null,
+    host: `${process.platform}-${process.arch}`
+  };
+}
+
+// src/doctor/checks.ts
+var EXPO_PUBLIC_PREFIX = "EXPO_PUBLIC_";
+function check(name, status, message) {
+  return { name, status, message };
+}
+function assertShellClean(ctx, checks) {
+  const leaked = Object.keys(ctx.env).filter((key) => key.startsWith(EXPO_PUBLIC_PREFIX) && ctx.env[key]);
+  if (leaked.length) {
+    checks.push(
+      check(
+        "shell-env",
+        "fail",
+        `shell tem ${leaked.join(", ")} exportado. Em build local isso vence as env vars do EAS. Unset antes de continuar.`
+      )
+    );
+    return;
+  }
+  checks.push(check("shell-env", "pass", "nenhum EXPO_PUBLIC_* no shell"));
+}
+function assertSentry(ctx, checks, channel) {
+  if (channel?.sentryUploadDisabled) {
+    checks.push(check("sentry", "pass", "canal desliga o upload de sourcemap; token n\xE3o \xE9 exigido."));
+    return;
+  }
+  const inShell = Boolean(ctx.env.SENTRY_AUTH_TOKEN);
+  if (!channel && !inShell) {
+    checks.push(check("sentry", "skip", "passe --channel para verificar SENTRY_AUTH_TOKEN no environment EAS."));
+    return;
+  }
+  if (inShell) {
+    checks.push(
+      check(
+        "sentry",
+        "warn",
+        "SENTRY_AUTH_TOKEN est\xE1 no shell e, em build local, vence o token do EAS. Prefira unset e deixe o environment EAS (Sensitive) injetar."
+      )
+    );
+    return;
+  }
+  const environment = channel?.easEnvironment;
+  if (environment && easEnvListHasKey(ctx, environment, "SENTRY_AUTH_TOKEN")) {
+    checks.push(check("sentry", "pass", `SENTRY_AUTH_TOKEN no environment EAS ${environment}.`));
+    return;
+  }
+  checks.push(
+    check(
+      "sentry",
+      "fail",
+      `SENTRY_AUTH_TOKEN ausente no shell e no environment EAS ${environment || "(defina easEnvironment no canal)"}.`
+    )
+  );
+}
+function assertEasAuth(ctx, checks, easOwner) {
+  const result = easWhoami(ctx);
+  if (ctx.dryRun) {
+    checks.push(check("eas-auth", "pass", "[dry-run] eas whoami"));
+    return;
+  }
+  if (!result.ok) {
+    checks.push(check("eas-auth", "fail", `eas whoami falhou. Rode \`eas login\` ou defina EXPO_TOKEN.
+${result.raw}`));
+    return;
+  }
+  if (easOwner && !result.raw.includes(easOwner)) {
+    checks.push(check("eas-auth", "fail", `eas whoami n\xE3o listou a conta ${easOwner}.`));
+    return;
+  }
+  checks.push(check("eas-auth", "pass", `autenticado${result.account ? ` como ${result.account}` : ""}`));
+}
+function assertToolchain(ctx, checks, config, { platform, allowToolchainDrift }) {
+  const baseline = config.toolchain;
+  const actual = collectToolchain(ctx);
+  const drift = [];
+  const compare = (name, spec, value, { platformOnly } = {}) => {
+    if (!spec) {
+      checks.push(check(`toolchain-${name}`, "skip", "sem baseline configurado"));
+      return;
+    }
+    if (platformOnly && platform && platform !== platformOnly) {
+      checks.push(check(`toolchain-${name}`, "skip", `n\xE3o exigido para --platform ${platform}`));
+      return;
+    }
+    if (!value) {
+      checks.push(check(`toolchain-${name}`, "fail", `${name} n\xE3o encontrado no PATH.`));
+      return;
+    }
+    if (spec.min && cmpVersion(value, spec.min) < 0) {
+      checks.push(check(`toolchain-${name}`, "fail", `${name} ${value} < m\xEDnimo ${spec.min}.`));
+      return;
+    }
+    if (spec.tested && cmpVersion(value, spec.tested) > 0) {
+      drift.push(`${name} ${value} > testado ${spec.tested}`);
+      checks.push(
+        check(
+          `toolchain-${name}`,
+          allowToolchainDrift ? "warn" : "fail",
+          `${name} ${value} est\xE1 acima do testado (${spec.tested}). Passe --allow-toolchain-drift para continuar.`
+        )
+      );
+      return;
+    }
+    checks.push(check(`toolchain-${name}`, "pass", `${name} ${value}`));
+  };
+  compare("eas-cli", baseline.easCli, actual.easCli);
+  compare("node", baseline.node, actual.node);
+  compare("jdk", baseline.jdk, actual.jdk, { platformOnly: "android" });
+  compare("xcode", baseline.xcode, actual.xcode, { platformOnly: "ios" });
+  compare("cocoapods", baseline.cocoapods, actual.cocoapods, { platformOnly: "ios" });
+  if (!platform || platform === "android") {
+    if (!ctx.env.JAVA_HOME) {
+      checks.push(check("java-home", "fail", "JAVA_HOME n\xE3o est\xE1 definido."));
+    } else {
+      checks.push(check("java-home", "pass", ctx.env.JAVA_HOME));
+    }
+    if (!ctx.env.ANDROID_HOME && !ctx.env.ANDROID_SDK_ROOT) {
+      checks.push(check("android-sdk", "fail", "ANDROID_HOME / ANDROID_SDK_ROOT ausente."));
+    } else {
+      checks.push(check("android-sdk", "pass", ctx.env.ANDROID_HOME || ctx.env.ANDROID_SDK_ROOT || ""));
+    }
+  }
+  if (platform === "ios" && process.platform !== "darwin") {
+    checks.push(check("platform-ios", "fail", "build local de iOS s\xF3 funciona no macOS. Use --cloud ou remova --platform ios."));
+  } else if (platform === "android" && process.platform === "win32") {
+    checks.push(
+      check(
+        "platform-android",
+        "warn",
+        "build local de Android no Windows n\xE3o \xE9 suportado pelo EAS fora do WSL2. Use --cloud ou rode dentro do WSL2."
+      )
+    );
+  }
+  return { actual, drift, toolchainDrift: drift.length > 0 };
+}
+function assertLockfileClean(ctx, checks) {
+  const pm = detectPackageManager(ctx.repoRoot);
+  const lockfile = { yarn: "yarn.lock", pnpm: "pnpm-lock.yaml", npm: "package-lock.json" }[pm];
+  const diff = ctx.run("git", ["diff", "--quiet", "HEAD", "--", lockfile], { cwd: ctx.repoRoot, inherit: false });
+  if (diff.status !== 0) {
+    checks.push(check("lockfile", "fail", `${lockfile} diverge do HEAD. Commit ou restaure antes do build (lockfile congelado).`));
+    return;
+  }
+  checks.push(check("lockfile", "pass", `${lockfile} igual ao HEAD`));
+}
+function assertRemoteVersion(ctx, checks, { platform, channel }) {
+  const remote = projectRemoteVersion(ctx, { platform, buildProfile: channel.buildProfile });
+  if (remote.dryRun) {
+    checks.push(check("remote-version", "pass", "[dry-run] eas build:version:get"));
+    return;
+  }
+  const projection = expectedBuildNumber(remote, { autoIncrement: channel.autoIncrement, platform });
+  if (!channel.autoIncrement) {
+    checks.push(
+      check(
+        "remote-version",
+        "pass",
+        `${projection.key} remoto atual: ${projection.current} (autoIncrement desligado; este build reutiliza o n\xFAmero).`
+      )
+    );
+    return;
+  }
+  checks.push(
+    check(
+      "remote-version",
+      "pass",
+      `${projection.key} remoto atual: ${projection.current} \u2192 esperado neste build: ${projection.expected} (s\xF3 \xE9 reservado quando o EAS iniciar o build).`
+    )
+  );
+}
+function assertFingerprint(ctx, checks, { channel, deep, buildId }) {
+  const environment = channel.easEnvironment;
+  if (!environment) {
+    checks.push(check("fingerprint", "skip", "canal sem easEnvironment configurado."));
+    return;
+  }
+  if (!deep) {
+    checks.push(check("fingerprint", "pass", `compara\xE7\xE3o contra build da nuvem s\xF3 em --deep (environment ${environment}).`));
+    return;
+  }
+  if (ctx.dryRun) {
+    checks.push(check("fingerprint", "pass", `[dry-run] eas fingerprint:generate --environment ${environment}`));
+    return;
+  }
+  const generated = easFingerprintGenerate(ctx, environment);
+  if (generated.status !== 0) {
+    checks.push(check("fingerprint", "fail", `eas fingerprint:generate falhou.
+${generated.stderr || generated.stdout}`));
+    return;
+  }
+  if (!buildId) {
+    checks.push(
+      check(
+        "fingerprint",
+        "pass",
+        `fingerprint local gerado. Para comparar com a nuvem: eas fingerprint:compare --build-id <id> --environment ${environment}`
+      )
+    );
+    return;
+  }
+  const compared = easFingerprintCompare(ctx, environment, buildId);
+  if (compared.status !== 0) {
+    checks.push(check("fingerprint", "fail", `eas fingerprint:compare falhou.
+${compared.stderr || compared.stdout}`));
+    return;
+  }
+  checks.push(check("fingerprint", "pass", `fingerprint local vs build ${buildId}`));
+}
+function assertExpoDoctor(ctx, checks, config) {
+  if (!config.doctor.expoDoctor) {
+    checks.push(check("expo-doctor", "skip", "desligado em doctor.expoDoctor"));
+    return;
+  }
+  if (ctx.dryRun) {
+    checks.push(check("expo-doctor", "pass", "[dry-run] npx expo-doctor"));
+    return;
+  }
+  const result = ctx.run("npx", ["expo-doctor"], { cwd: ctx.appDir, inherit: false });
+  if (result.status !== 0) {
+    const detail = (result.stdout || result.stderr || "").trim();
+    checks.push(
+      check("expo-doctor", "fail", `expo-doctor saiu com c\xF3digo ${result.status}. Atualize as depend\xEAncias com \`npx expo install\`.${detail ? `
+${detail}` : ""}`)
+    );
+    return;
+  }
+  checks.push(check("expo-doctor", "pass", "expo-doctor ok"));
+}
+function assertEasJsonExists(ctx) {
+  if (!existsSync4(join4(ctx.appDir, "eas.json"))) {
+    throw new Error(`eas.json n\xE3o encontrado em ${ctx.appDir}. Rode \`eas init\` ou \`release-kit init\`.`);
+  }
+}
+
+// src/doctor/run.ts
+function runDoctor(ctx, config, opts) {
+  assertEasJsonExists(ctx);
+  const channel = opts.channel ? channelOf(config, opts.channel) : null;
+  if (opts.platform && !config.platforms.includes(opts.platform)) {
+    fail(`--platform ${opts.platform} n\xE3o est\xE1 em config.platforms (${config.platforms.join(", ")}).`);
+  }
+  const checks = [];
+  const version = readAppVersion(ctx.appDir, config);
+  checks.push(...checkGitPolicy(ctx, config.git, { version, isProtectedChannel: Boolean(channel?.protected) }));
+  assertShellClean(ctx, checks);
+  if (config.doctor.sentry) {
+    assertSentry(ctx, checks, channel);
+  } else {
+    checks.push({ name: "sentry", status: "skip", message: "desligado em doctor.sentry" });
+  }
+  assertEasAuth(ctx, checks, config.easOwner);
+  const toolchain = assertToolchain(ctx, checks, config, {
+    platform: opts.platform,
+    allowToolchainDrift: opts.allowToolchainDrift
+  });
+  assertLockfileClean(ctx, checks);
+  if (channel && opts.platform) {
+    assertRemoteVersion(ctx, checks, { platform: opts.platform, channel });
+    assertFingerprint(ctx, checks, { channel, deep: opts.deep, buildId: opts.buildId });
+  } else {
+    checks.push({ name: "remote-version", status: "skip", message: "passe --channel e --platform para consultar versionCode/buildNumber" });
+    checks.push({ name: "fingerprint", status: "skip", message: "passe --channel para avaliar runtimeVersion" });
+  }
+  assertExpoDoctor(ctx, checks, config);
+  const failed = checks.filter((item) => item.status === "fail");
+  return {
+    ok: failed.length === 0,
+    checks,
+    toolchainDrift: toolchain.toolchainDrift
+  };
+}
+function requireDoctorPass(report) {
+  if (report.ok) return;
+  const failed = report.checks.filter((item) => item.status === "fail");
+  const summary = failed.map((item) => `- ${item.name}: ${item.message}`).join("\n");
+  fail(`doctor falhou:
+${summary}`);
+}
+
+// src/release/build.ts
+import { copyFileSync, existsSync as existsSync6, mkdirSync as mkdirSync2, unlinkSync } from "fs";
+import { dirname, join as join6, resolve } from "path";
+
+// src/eas/profiles.ts
+function resolveBuildProfileChain(easJson, profileName) {
+  const build = easJson.build ?? {};
+  const profile = build[profileName];
+  if (!profile) fail(`build profile "${profileName}" n\xE3o existe no eas.json.`);
+  const chain = [profile];
+  let cursor = profile;
+  const seen = /* @__PURE__ */ new Set([profileName]);
+  while (cursor?.extends) {
+    const parentName = cursor.extends;
+    if (seen.has(parentName)) break;
+    seen.add(parentName);
+    const parent = build[parentName];
+    if (!parent) break;
+    chain.push(parent);
+    cursor = parent;
+  }
+  const merged = {};
+  for (const step of chain.slice().reverse()) {
+    Object.assign(merged, step);
+    if (step.android) merged.android = { ...merged.android, ...step.android };
+    if (step.ios) merged.ios = { ...merged.ios, ...step.ios };
+  }
+  return merged;
+}
+function androidBuildTypeExt(easJson, profileName) {
+  const resolved = resolveBuildProfileChain(easJson, profileName);
+  return resolved.android?.buildType === "apk" ? "apk" : "aab";
+}
+
+// src/release/gate.ts
+function assertChannelOptIn(ctx, config, channel, opts) {
+  if (!channel.protected) return;
+  if (opts.iKnowThisIsProduction) return;
+  const version = readAppVersion(ctx.appDir, config);
+  if (opts.confirmVersion && opts.confirmVersion.trim() === version) return;
+  fail(
+    `canal protegido: passe --i-know-this-is-production (n\xE3o-interativo) ou confirme digitando a vers\xE3o exata (${version}). \`release-kit\` sem argumentos nunca resolve para um canal protegido.`
+  );
+}
+
+// src/release/metadata.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync5, mkdirSync, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync, writeFileSync as writeFileSync3 } from "fs";
+import { join as join5 } from "path";
+function sha256File(path) {
+  return createHash("sha256").update(readFileSync4(path)).digest("hex");
+}
+function gitInfo(ctx) {
+  const sha = git(ctx, ["rev-parse", "HEAD"]).stdout.trim();
+  const branch = git(ctx, ["rev-parse", "--abbrev-ref", "HEAD"]).stdout.trim();
+  const tagResult = git(ctx, ["tag", "--points-at", "HEAD"], { allowFail: true });
+  const tag = (tagResult.stdout || "").split("\n").map((line) => line.trim()).find((line) => /^v\d/.test(line)) || "";
+  return { sha, branch, tag };
+}
+function writeMetadata(dir, payload) {
+  mkdirSync(dir, { recursive: true });
+  writeFileSync3(join5(dir, "metadata.json"), `${JSON.stringify(payload, null, 2)}
+`);
+  return payload;
+}
+function findLatestMetadata(releaseDir, { channel, platform } = {}) {
+  if (!existsSync5(releaseDir)) fail(`Nenhum artefato em ${releaseDir}. Rode \`release-kit build\` primeiro.`);
+  const entries = readdirSync2(releaseDir).map((name) => {
+    const dir = join5(releaseDir, name);
+    const metaPath = join5(dir, "metadata.json");
+    if (!statSync(dir).isDirectory() || !existsSync5(metaPath)) return null;
+    const metadata = JSON.parse(readFileSync4(metaPath, "utf8"));
+    if (platform && metadata.platform !== platform) return null;
+    if (channel && metadata.channel !== channel) return null;
+    return { dir, metaPath, metadata, createdAt: metadata.createdAt || "" };
+  }).filter((entry) => entry !== null).sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+  const [first] = entries;
+  if (!first) {
+    fail(`Nenhum metadata.json${platform ? ` para ${platform}` : ""}${channel ? ` (canal ${channel})` : ""} em ${releaseDir}.`);
+  }
+  return first;
+}
+
+// src/release/build.ts
+function artifactExt(ctx, platform, buildProfile) {
+  if (platform === "ios") return "ipa";
+  const easJson = readEasJson(ctx.appDir);
+  if (!easJson) fail(`eas.json n\xE3o encontrado em ${ctx.appDir}.`);
+  return androidBuildTypeExt(easJson, buildProfile);
+}
+function buildRelease(ctx, config, opts) {
+  const channel = channelOf(config, opts.channel);
+  assertChannelOptIn(ctx, config, channel, opts);
+  if (!config.platforms.includes(opts.platform)) {
+    fail(`--platform ${opts.platform} n\xE3o est\xE1 em config.platforms.`);
+  }
+  const ext = artifactExt(ctx, opts.platform, channel.buildProfile);
+  const staging = opts.output ? resolve(ctx.repoRoot, opts.output) : join6(ctx.releaseDir, `_building-${opts.platform}-${opts.channel}.${ext}`);
+  const local = !opts.cloud;
+  if (ctx.dryRun) {
+    const env = channel.env;
+    const command = formatCommand("eas", ["build", "-p", opts.platform, "--profile", channel.buildProfile, ...local ? ["--local"] : [], "--output", staging], env);
+    ctx.log.info(`[dry-run] cd ${ctx.appDir} && ${command}`);
+    return { dryRun: true, command, staging };
+  }
+  mkdirSync2(dirname(staging), { recursive: true });
+  ctx.log.step(`eas build ${local ? "--local" : "(cloud)"} (${opts.platform}/${opts.channel})`);
+  requireSuccess(
+    easBuild(ctx, { platform: opts.platform, buildProfile: channel.buildProfile, local, output: local ? staging : void 0, env: channel.env }),
+    "eas build"
+  );
+  if (local && !existsSync6(staging)) fail(`Build concluiu sem artefato em ${staging}.`);
+  const remote = projectRemoteVersion(ctx, { platform: opts.platform, buildProfile: channel.buildProfile });
+  const version = readAppVersion(ctx.appDir, config);
+  const versionCode = remote.versionCode;
+  const buildNumber = opts.platform === "ios" ? remote.buildNumber : remote.versionCode;
+  const git2 = gitInfo(ctx);
+  const dirName = `${opts.platform}-${opts.channel}-${version}-${buildNumber || "unknown"}`;
+  const finalDir = join6(ctx.releaseDir, dirName);
+  mkdirSync2(finalDir, { recursive: true });
+  const finalPath = local ? join6(finalDir, `app.${ext}`) : "";
+  if (local && resolve(staging) !== resolve(finalPath)) {
+    copyFileSync(staging, finalPath);
+    if (staging.includes("_building-")) {
+      try {
+        unlinkSync(staging);
+      } catch {
+      }
+    }
+  }
+  const metadata = writeMetadata(finalDir, {
+    platform: opts.platform,
+    channel: opts.channel,
+    buildProfile: channel.buildProfile,
+    version,
+    buildNumber,
+    versionCode,
+    artifactPath: finalPath,
+    sha256: local && existsSync6(finalPath) ? sha256File(finalPath) : "",
+    commitSha: git2.sha,
+    branch: git2.branch,
+    tag: git2.tag,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    toolchain: collectToolchain(ctx),
+    toolchainDrift: Boolean(opts.toolchainDrift)
+  });
+  if (local) {
+    ctx.log.success(`artefato ${finalPath}`);
+  } else {
+    ctx.log.success("build enviado ao EAS Build Cloud \u2014 use `eas build:list` para acompanhar e baixar o artefato.");
+  }
+  ctx.log.success(`metadata ${join6(finalDir, "metadata.json")}`);
+  return { artifactPath: finalPath, metadata };
+}
+
+// src/release/submit.ts
+import { existsSync as existsSync7 } from "fs";
+import { resolve as resolve2 } from "path";
+function inferPlatformFromArtifact(artifactPath) {
+  const lower = artifactPath.toLowerCase();
+  if (lower.endsWith(".apk")) {
+    fail("Submit Android exige AAB. O profile de sideload n\xE3o vai \xE0 loja; gere o bin\xE1rio com um profile de release/production.");
+  }
+  if (lower.endsWith(".aab")) return "android";
+  if (lower.endsWith(".ipa")) return "ios";
+  fail("submit --path exige um arquivo .aab ou .ipa.");
+}
+function submitRelease(ctx, config, opts) {
+  const channel = channelOf(config, opts.channel);
+  assertChannelOptIn(ctx, config, channel, opts);
+  if (!channel.store) {
+    fail(`canal "${opts.channel}" n\xE3o envia \xE0 loja (store: false).`);
+  }
+  const submitProfile = channel.submitProfile ?? channel.buildProfile;
+  let artifactPath;
+  let platform;
+  if (opts.path) {
+    artifactPath = resolve2(ctx.repoRoot, opts.path);
+    if (!existsSync7(artifactPath)) fail(`Artefato n\xE3o encontrado: ${artifactPath}.`);
+    platform = inferPlatformFromArtifact(artifactPath);
+    if (opts.platform && opts.platform !== platform) {
+      fail(`--platform ${opts.platform} n\xE3o corresponde ao arquivo (${platform}).`);
+    }
+  } else {
+    const entry = findLatestMetadata(ctx.releaseDir, { channel: opts.channel, platform: opts.platform });
+    const metadata = entry.metadata;
+    artifactPath = metadata.artifactPath;
+    platform = metadata.platform;
+    if (!artifactPath || !existsSync7(artifactPath)) {
+      fail(`Artefato n\xE3o encontrado: ${artifactPath || "(ausente no metadata)"}. Builds na nuvem n\xE3o t\xEAm artefato local \u2014 use --path ap\xF3s baixar.`);
+    }
+  }
+  if (platform === "android" && !artifactPath.toLowerCase().endsWith(".aab")) {
+    fail("Submit Android exige AAB.");
+  }
+  if (ctx.dryRun) {
+    const command = formatCommand("eas", ["submit", "-p", platform, "--profile", submitProfile, "--path", artifactPath], channel.env);
+    ctx.log.info(`[dry-run] cd ${ctx.appDir} && ${command}`);
+    return { dryRun: true, command, submitProfile, artifactPath };
+  }
+  ctx.log.step(`eas submit --path (${platform}/${submitProfile})`);
+  requireSuccess(easSubmit(ctx, { platform, submitProfile, path: artifactPath, env: channel.env }), "eas submit");
+  return { submitProfile, artifactPath };
+}
+
+// src/release/ship.ts
+function shipRelease(ctx, config, opts) {
+  const channel = channelOf(config, opts.channel);
+  if (!channel.store) {
+    fail(`canal "${opts.channel}" n\xE3o envia \xE0 loja (store: false). Use \`release-kit build\` direto para gerar o artefato de sideload.`);
+  }
+  let toolchainDrift = opts.toolchainDrift;
+  if (!opts.skipDoctor) {
+    const report = runDoctor(ctx, config, {
+      channel: opts.channel,
+      platform: opts.platform,
+      allowToolchainDrift: opts.allowToolchainDrift
+    });
+    requireDoctorPass(report);
+    toolchainDrift = report.toolchainDrift;
+  }
+  const built = buildRelease(ctx, config, { ...opts, toolchainDrift });
+  if (ctx.dryRun) return { dryRun: true, artifactPath: built.artifactPath };
+  const submitted = submitRelease(ctx, config, {
+    channel: opts.channel,
+    platform: opts.platform,
+    latest: true,
+    iKnowThisIsProduction: opts.iKnowThisIsProduction,
+    confirmVersion: opts.confirmVersion
+  });
+  return { artifactPath: built.artifactPath, submit: submitted };
+}
+
+// src/release/version.ts
+import { relative } from "path";
+function bumpVersion(ctx, config, opts) {
+  if (!isWorkingTreeClean(ctx)) {
+    fail("working tree suja. Commit ou descarte as mudan\xE7as antes de rodar `release-kit version`.");
+  }
+  const current = readAppVersion(ctx.appDir, config);
+  const next = nextVersion(current, opts.bump);
+  const tag = renderTag(config.git.tagFormat, next);
+  if (ctx.dryRun) {
+    ctx.log.info(`[dry-run] ${current} \u2192 ${next} (tag ${tag})`);
+    return { from: current, to: next, tag, dryRun: true };
+  }
+  const path = writeAppVersion(ctx.appDir, config, next);
+  const relPath = relative(ctx.repoRoot, path);
+  git(ctx, ["add", relPath]);
+  git(ctx, ["commit", "-m", `chore(release): ${tag}`]);
+  git(ctx, ["tag", tag]);
+  ctx.log.success(`${current} \u2192 ${next} (commit + tag ${tag})`);
+  if (opts.push) {
+    requireSuccess(git(ctx, ["push", config.git.remote, config.git.releaseBranch]), "git push");
+    requireSuccess(git(ctx, ["push", config.git.remote, tag]), "git push tag");
+    ctx.log.success(`push ${config.git.remote} ${config.git.releaseBranch} + tag ${tag}`);
+  }
+  return { from: current, to: next, tag };
+}
+
+// src/release/notes.ts
+import { existsSync as existsSync9 } from "fs";
+
+// src/notes/draft.ts
+function draftNotes(commits, version) {
+  const facing = userFacingCommits(commits);
+  if (facing.length === 0) {
+    return `Novidades da vers\xE3o ${version}
+
+(sem commits feat/fix desde a \xFAltima tag \u2014 escreva as notas manualmente)
+`;
+  }
+  const features = facing.filter((c) => c.type === "feat");
+  const fixes = facing.filter((c) => c.type === "fix");
+  const lines = [`Novidades da vers\xE3o ${version}`, ""];
+  if (features.length) {
+    lines.push("Novidades:");
+    for (const commit of features) lines.push(`- ${capitalize(commit.description)}`);
+    lines.push("");
+  }
+  if (fixes.length) {
+    lines.push("Corre\xE7\xF5es:");
+    for (const commit of fixes) lines.push(`- ${capitalize(commit.description)}`);
+    lines.push("");
+  }
+  lines.push("# Revise este rascunho antes de publicar \u2014 ele vem direto dos commits (feat/fix) e n\xE3o foi reescrito em linguagem de usu\xE1rio.");
+  return lines.join("\n");
+}
+function capitalize(text) {
+  if (!text) return text;
+  return text[0].toUpperCase() + text.slice(1);
+}
+
+// src/notes/editor.ts
+function defaultEditor() {
+  if (process.platform === "win32") return "notepad";
+  return "nano";
+}
+function openInEditor(ctx, path) {
+  const editor = ctx.env.EDITOR || ctx.env.VISUAL || defaultEditor();
+  const [command, ...args] = editor.split(" ");
+  if (!command) return;
+  requireSuccess(ctx.run(command, [...args, path], { inherit: true }), `${editor} ${path}`);
+}
+
+// src/notes/limits.ts
+var PLAY_NOTES_MAX = 500;
+var APPLE_WHATS_NEW_MAX = 4e3;
+function notesMaxFor(target) {
+  return target === "play" ? PLAY_NOTES_MAX : APPLE_WHATS_NEW_MAX;
+}
+function assertNotesWithinLimit(text, target, locale) {
+  const max = notesMaxFor(target);
+  if (text.length > max) {
+    fail(`Notas ${target} (${locale}) t\xEAm ${text.length} caracteres (m\xE1ximo ${max}).`);
+  }
+  if (!text.trim()) {
+    fail(`Notas ${target} (${locale}) est\xE3o vazias.`);
+  }
+}
+
+// src/notes/paths.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { join as join7 } from "path";
+function notesDirFor(appDir, notesDir, version) {
+  return join7(appDir, notesDir, version);
+}
+function notesFilePath(appDir, notesDir, version, locale, target) {
+  return join7(notesDirFor(appDir, notesDir, version), `${locale}.${target}.txt`);
+}
+function readNotesFile(path) {
+  if (!existsSync8(path)) fail(`Notas n\xE3o encontradas: ${path}. Rode \`release-kit notes\` primeiro.`);
+  const text = readFileSync5(path, "utf8").trim();
+  if (!text) fail(`Notas vazias em ${path}.`);
+  return text;
+}
+function writeNotesFile(path, text) {
+  mkdirSync3(join7(path, ".."), { recursive: true });
+  writeFileSync4(path, `${text.trim()}
+`);
+}
+
+// src/release/notes.ts
+function targetsFor(config) {
+  const targets = [];
+  if (config.platforms.includes("ios")) targets.push("ios");
+  if (config.platforms.includes("android")) targets.push("play");
+  return targets;
+}
+function draftAndEditNotes(ctx, config, opts) {
+  const version = opts.version ?? readAppVersion(ctx.appDir, config);
+  const commits = commitsSinceLastTag(ctx, config.git.tagFormat);
+  const targets = targetsFor(config);
+  const files = [];
+  for (const locale of config.locales) {
+    for (const target of targets) {
+      const path = notesFilePath(ctx.appDir, config.notesDir, version, locale, target);
+      const isNew = !existsSync9(path);
+      if (isNew) {
+        writeNotesFile(path, draftNotes(commits, version));
+        ctx.log.step(`rascunho criado: ${path}`);
+      }
+      if (!opts.skipEditor && (isNew || opts.edit)) {
+        openInEditor(ctx, path);
+      }
+      const text = readNotesFile(path);
+      assertNotesWithinLimit(text, target, locale);
+      files.push({ path, target, locale });
+    }
+  }
+  return { version, files };
+}
+
+// src/stores/credentials.ts
+import { existsSync as existsSync11, readFileSync as readFileSync7 } from "fs";
+
+// src/env/store.ts
+import { chmodSync, copyFileSync as copyFileSync2, existsSync as existsSync10, mkdirSync as mkdirSync4, mkdtempSync, readFileSync as readFileSync6, rmSync, writeFileSync as writeFileSync5 } from "fs";
+import { homedir, tmpdir } from "os";
+import { basename, join as join8 } from "path";
+import dotenv from "dotenv";
+function materializeSecretContent(content, filename) {
+  const dir = mkdtempSync(join8(tmpdir(), "release-kit-"));
+  const path = join8(dir, filename);
+  writeFileSync5(path, content);
+  try {
+    chmodSync(path, 384);
+  } catch {
+  }
+  return {
+    path,
+    cleanup: () => rmSync(dir, { recursive: true, force: true })
+  };
+}
+function resolveFileCredential(env, pathKey, contentKey, filename) {
+  const directPath = env[pathKey];
+  if (directPath) return { path: directPath, cleanup: () => {
+  } };
+  const content = env[contentKey];
+  if (content) return materializeSecretContent(content, filename);
+  return null;
+}
+
+// src/stores/apple/auth.ts
+import { createPrivateKey, createSign } from "crypto";
+function base64url(input) {
+  const buffer = typeof input === "string" ? Buffer.from(input) : input;
+  return buffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function createAppStoreConnectToken(credentials, now = Date.now()) {
+  const iat = Math.floor(now / 1e3);
+  const exp = iat + 19 * 60;
+  const header = base64url(JSON.stringify({ alg: "ES256", kid: credentials.keyId, typ: "JWT" }));
+  const payload = base64url(
+    JSON.stringify({
+      iss: credentials.issuerId,
+      iat,
+      exp,
+      aud: "appstoreconnect-v1"
+    })
+  );
+  const signingInput = `${header}.${payload}`;
+  const key = createPrivateKey({ key: credentials.privateKeyPem, format: "pem" });
+  const signer = createSign("SHA256");
+  signer.update(signingInput);
+  signer.end();
+  const signature = signer.sign({ key, dsaEncoding: "ieee-p1363" });
+  return `${signingInput}.${base64url(signature)}`;
+}
+
+// src/stores/apple/client.ts
+var APP_STORE_CONNECT_BASE = "https://api.appstoreconnect.apple.com/v1";
+var AppStoreConnectClient = class {
+  credentials;
+  baseUrl;
+  fetchImpl;
+  constructor(options) {
+    this.credentials = options.credentials;
+    this.baseUrl = options.baseUrl ?? APP_STORE_CONNECT_BASE;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+  }
+  token() {
+    return createAppStoreConnectToken(this.credentials);
+  }
+  async request(method, path, body) {
+    const url = path.startsWith("http") ? path : `${this.baseUrl}${path}`;
+    const response = await this.fetchImpl(url, {
+      method,
+      headers: {
+        Authorization: `Bearer ${this.token()}`,
+        "Content-Type": "application/json"
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    const text = await response.text();
+    if (!response.ok) {
+      fail(`App Store Connect API ${method} ${path} \u2192 ${response.status}
+${text}`);
+    }
+    if (!text) return void 0;
+    return JSON.parse(text);
+  }
+  get(path) {
+    return this.request("GET", path);
+  }
+  post(path, body) {
+    return this.request("POST", path, body);
+  }
+  patch(path, body) {
+    return this.request("PATCH", path, body);
+  }
+};
+
+// src/stores/google/auth.ts
+import { createSign as createSign2 } from "crypto";
+function parseServiceAccountJson(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    fail(`JSON da service account inv\xE1lido: ${error.message}`);
+  }
+  const account = parsed;
+  if (!account.client_email || !account.private_key) {
+    fail("JSON da service account sem client_email/private_key.");
+  }
+  return account;
+}
+function base64url2(input) {
+  const buffer = typeof input === "string" ? Buffer.from(input) : input;
+  return buffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+var TOKEN_URL = "https://oauth2.googleapis.com/token";
+var ANDROID_PUBLISHER_SCOPE = "https://www.googleapis.com/auth/androidpublisher";
+async function fetchAccessToken(account, fetchImpl = fetch, now = Date.now()) {
+  const iat = Math.floor(now / 1e3);
+  const exp = iat + 60 * 60;
+  const header = base64url2(JSON.stringify({ alg: "RS256", typ: "JWT" }));
+  const payload = base64url2(
+    JSON.stringify({
+      iss: account.client_email,
+      scope: ANDROID_PUBLISHER_SCOPE,
+      aud: TOKEN_URL,
+      iat,
+      exp
+    })
+  );
+  const signingInput = `${header}.${payload}`;
+  const signer = createSign2("RSA-SHA256");
+  signer.update(signingInput);
+  signer.end();
+  const signature = signer.sign(account.private_key);
+  const assertion = `${signingInput}.${base64url2(signature)}`;
+  const response = await fetchImpl(TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
+      assertion
+    }).toString()
+  });
+  const text = await response.text();
+  if (!response.ok) fail(`Falha ao obter access_token do Google: ${response.status}
+${text}`);
+  const json = JSON.parse(text);
+  if (!json.access_token) fail("Resposta do Google sem access_token.");
+  return json.access_token;
+}
+
+// src/stores/google/client.ts
+var ANDROID_PUBLISHER_BASE = "https://androidpublisher.googleapis.com/androidpublisher/v3";
+var AndroidPublisherClient = class {
+  account;
+  baseUrl;
+  fetchImpl;
+  cachedToken = null;
+  constructor(options) {
+    this.account = options.account;
+    this.baseUrl = options.baseUrl ?? ANDROID_PUBLISHER_BASE;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+  }
+  async token() {
+    if (!this.cachedToken) {
+      this.cachedToken = await fetchAccessToken(this.account, this.fetchImpl);
+    }
+    return this.cachedToken;
+  }
+  async request(method, path, body) {
+    const token = await this.token();
+    const response = await this.fetchImpl(`${this.baseUrl}${path}`, {
+      method,
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    const text = await response.text();
+    if (!response.ok) fail(`Android Publisher API ${method} ${path} \u2192 ${response.status}
+${text}`);
+    if (!text) return void 0;
+    return JSON.parse(text);
+  }
+  get(path) {
+    return this.request("GET", path);
+  }
+  put(path, body) {
+    return this.request("PUT", path, body);
+  }
+  post(path, body) {
+    return this.request("POST", path, body);
+  }
+  delete(path) {
+    return this.request("DELETE", path);
+  }
+};
+
+// src/stores/credentials.ts
+function createAppleClient(env) {
+  const keyId = env.ASC_KEY_ID;
+  const issuerId = env.ASC_ISSUER_ID;
+  if (!keyId || !issuerId) {
+    fail("Credenciais App Store Connect ausentes: ASC_KEY_ID, ASC_ISSUER_ID. Rode `release-kit credentials apple`.");
+  }
+  const resolved = resolveFileCredential(env, "ASC_KEY_PATH", "ASC_KEY_P8_CONTENT", "AuthKey.p8");
+  if (!resolved) {
+    fail("Credencial ASC_KEY_PATH (ou ASC_KEY_P8_CONTENT em CI) ausente. Rode `release-kit credentials apple`.");
+  }
+  if (!existsSync11(resolved.path)) fail(`ASC_KEY_PATH n\xE3o existe: ${resolved.path}`);
+  const privateKeyPem = readFileSync7(resolved.path, "utf8");
+  const client = new AppStoreConnectClient({ credentials: { keyId, issuerId, privateKeyPem } });
+  return Object.assign(client, { cleanup: resolved.cleanup });
+}
+function createGoogleClient(env) {
+  const resolved = resolveFileCredential(env, "GOOGLE_PLAY_JSON_KEY", "GOOGLE_PLAY_JSON_CONTENT", "play-service-account.json");
+  if (!resolved) {
+    fail(
+      "Credencial GOOGLE_PLAY_JSON_KEY (ou GOOGLE_PLAY_JSON_CONTENT em CI) ausente. Rode `release-kit credentials google`."
+    );
+  }
+  if (!existsSync11(resolved.path)) fail(`GOOGLE_PLAY_JSON_KEY n\xE3o existe: ${resolved.path}`);
+  const account = parseServiceAccountJson(readFileSync7(resolved.path, "utf8"));
+  const client = new AndroidPublisherClient({ account });
+  return Object.assign(client, { cleanup: resolved.cleanup });
+}
+
+// src/stores/google/tracks.ts
+async function withEdit(client, packageName, fn) {
+  const edit = await client.post(`/applications/${packageName}/edits`);
+  try {
+    const result = await fn(edit.id);
+    await client.post(`/applications/${packageName}/edits/${edit.id}:commit`);
+    return result;
+  } catch (error) {
+    await client.delete(`/applications/${packageName}/edits/${edit.id}`).catch(() => {
+    });
+    throw error;
+  }
+}
+async function withReadOnlyEdit(client, packageName, fn) {
+  const edit = await client.post(`/applications/${packageName}/edits`);
+  try {
+    return await fn(edit.id);
+  } finally {
+    await client.delete(`/applications/${packageName}/edits/${edit.id}`).catch(() => {
+    });
+  }
+}
+function findTargetRelease(releases, versionCode) {
+  if (versionCode) {
+    return releases.find((release) => (release.versionCodes ?? []).includes(String(versionCode)));
+  }
+  return releases.find((release) => release.status === "completed") ?? releases[0];
+}
+async function promoteRelease(client, input) {
+  return withEdit(client, input.packageName, async (editId) => {
+    const source = await client.get(`/applications/${input.packageName}/edits/${editId}/tracks/${input.fromTrack}`);
+    const releases = source.releases ?? [];
+    const target = findTargetRelease(releases);
+    if (!target || !target.versionCodes?.length) {
+      fail(`faixa ${input.fromTrack} sem release para promover.`);
+    }
+    const fraction = input.initialRollout ?? 1;
+    const status = fraction < 1 ? "inProgress" : "completed";
+    const releaseNotes = input.notesByLocale ? Object.entries(input.notesByLocale).map(([language, text]) => ({ language, text })) : target.releaseNotes;
+    const newRelease = {
+      versionCodes: target.versionCodes,
+      status,
+      releaseNotes,
+      ...status === "inProgress" ? { userFraction: fraction } : {}
+    };
+    await client.put(`/applications/${input.packageName}/edits/${editId}/tracks/${input.toTrack}`, {
+      track: input.toTrack,
+      releases: [newRelease]
+    });
+    return newRelease;
+  });
+}
+async function setRollout(client, packageName, track, target) {
+  return withEdit(client, packageName, async (editId) => {
+    const current = await client.get(`/applications/${packageName}/edits/${editId}/tracks/${track}`);
+    const releases = current.releases ?? [];
+    const active = releases.find((release) => release.status === "inProgress") ?? releases[releases.length - 1];
+    if (!active) fail(`faixa ${track} sem release em rollout.`);
+    if (target === "complete") {
+      active.status = "completed";
+      delete active.userFraction;
+    } else if (target === "halt") {
+      active.status = "halted";
+    } else {
+      if (target <= 0 || target > 1) fail(`--to precisa ser um valor entre 0 e 1 (ou complete/halt).`);
+      active.status = "inProgress";
+      active.userFraction = target;
+    }
+    await client.put(`/applications/${packageName}/edits/${editId}/tracks/${track}`, { track, releases });
+    return active;
+  });
+}
+async function getTrackStatus(client, packageName, track) {
+  return withReadOnlyEdit(
+    client,
+    packageName,
+    (editId) => client.get(`/applications/${packageName}/edits/${editId}/tracks/${track}`)
+  );
+}
+
+// src/stores/apple/apps.ts
+async function findAppByBundleId(client, bundleId) {
+  const result = await client.get(`/apps?filter[bundleId]=${encodeURIComponent(bundleId)}`);
+  const [app] = result.data;
+  if (!app) return null;
+  return { id: app.id, name: app.attributes.name };
+}
+async function requireAppByBundleId(client, bundleId) {
+  const app = await findAppByBundleId(client, bundleId);
+  if (!app) fail(`App com bundleId ${bundleId} n\xE3o encontrado no App Store Connect (chave sem acesso ao app, ou app ainda n\xE3o criado).`);
+  return app;
+}
+
+// src/stores/apple/review.ts
+var IN_PROGRESS_STATES = /* @__PURE__ */ new Set(["READY_FOR_REVIEW", "WAITING_FOR_REVIEW", "IN_REVIEW", "PROCESSING"]);
+var TERMINAL_STATES = /* @__PURE__ */ new Set(["COMPLETE", "CANCELED"]);
+async function submitForReview(client, input) {
+  const app = await requireAppByBundleId(client, input.bundleId);
+  const inProgress = await findInProgressReviewSubmission(client, app.id);
+  if (inProgress) {
+    return {
+      appId: app.id,
+      appStoreVersionId: "",
+      buildId: "",
+      submissionId: inProgress.id,
+      state: inProgress.attributes.state,
+      alreadyInProgress: true
+    };
+  }
+  const version = await ensureAppStoreVersion(client, app.id, input.versionString);
+  if (input.copyright && !version.attributes.copyright) {
+    await client.patch(`/appStoreVersions/${version.id}`, {
+      data: { id: version.id, type: "appStoreVersions", attributes: { copyright: input.copyright } }
+    });
+  }
+  await client.patch(`/appStoreVersions/${version.id}`, {
+    data: {
+      id: version.id,
+      type: "appStoreVersions",
+      attributes: { releaseType: input.automaticRelease ? "AFTER_APPROVAL" : "MANUAL" }
+    }
+  });
+  const build = await findValidBuild(client, app.id, input.versionString);
+  if (!build) fail(`Nenhum build VALID no TestFlight para a vers\xE3o ${input.versionString}.`);
+  await client.request("POST", `/appStoreVersions/${version.id}/relationships/build`, {
+    data: { id: build.id, type: "builds" }
+  });
+  if (input.phasedRelease) {
+    await client.post("/appStoreVersionPhasedReleases", {
+      data: {
+        type: "appStoreVersionPhasedReleases",
+        relationships: { appStoreVersion: { data: { id: version.id, type: "appStoreVersions" } } }
+      }
+    });
+  }
+  for (const [locale, whatsNew] of Object.entries(input.whatsNewByLocale)) {
+    const localization = await findLocalization(client, version.id, locale);
+    if (!localization) fail(`Localization ${locale} ausente na vers\xE3o ${input.versionString} do App Store Connect.`);
+    await client.patch(`/appStoreVersionLocalizations/${localization.id}`, {
+      data: { id: localization.id, type: "appStoreVersionLocalizations", attributes: { whatsNew } }
+    });
+  }
+  const submission = await createReviewSubmission(client, app.id);
+  await client.post("/reviewSubmissionItems", {
+    data: {
+      type: "reviewSubmissionItems",
+      relationships: {
+        reviewSubmission: { data: { id: submission.id, type: "reviewSubmissions" } },
+        appStoreVersion: { data: { id: version.id, type: "appStoreVersions" } }
+      }
+    }
+  });
+  const submitted = await client.patch(`/reviewSubmissions/${submission.id}`, {
+    data: { id: submission.id, type: "reviewSubmissions", attributes: { submitted: true } }
+  });
+  return {
+    appId: app.id,
+    appStoreVersionId: version.id,
+    buildId: build.id,
+    submissionId: submission.id,
+    state: submitted.data.attributes.state,
+    alreadyInProgress: false
+  };
+}
+async function getIosStatus(client, bundleId, versionString) {
+  const app = await requireAppByBundleId(client, bundleId);
+  const version = await findAppStoreVersion(client, app.id, versionString);
+  const inProgress = await findInProgressReviewSubmission(client, app.id);
+  return {
+    appId: app.id,
+    versionString,
+    appStoreState: version?.attributes.appStoreState ?? null,
+    reviewSubmissionState: inProgress?.attributes.state ?? null
+  };
+}
+async function findInProgressReviewSubmission(client, appId) {
+  const result = await client.get(
+    `/apps/${appId}/reviewSubmissions?filter[platform]=IOS`
+  );
+  const active = result.data.find(
+    (item) => IN_PROGRESS_STATES.has(item.attributes.state) && !TERMINAL_STATES.has(item.attributes.state)
+  );
+  return active ?? null;
+}
+async function ensureAppStoreVersion(client, appId, versionString) {
+  const existing = await findAppStoreVersion(client, appId, versionString);
+  if (existing) return existing;
+  const created = await client.post("/appStoreVersions", {
+    data: {
+      type: "appStoreVersions",
+      attributes: { platform: "IOS", versionString },
+      relationships: { app: { data: { id: appId, type: "apps" } } }
+    }
+  });
+  return { id: created.data.id, attributes: created.data.attributes };
+}
+async function findAppStoreVersion(client, appId, versionString) {
+  const result = await client.get(
+    `/apps/${appId}/appStoreVersions?filter[versionString]=${encodeURIComponent(versionString)}&filter[platform]=IOS`
+  );
+  const [version] = result.data;
+  return version ? { id: version.id, attributes: version.attributes } : null;
+}
+async function findValidBuild(client, appId, versionString) {
+  const result = await client.get(
+    `/builds?filter[app]=${appId}&filter[preReleaseVersion.version]=${encodeURIComponent(versionString)}&sort=-uploadedDate&limit=20`
+  );
+  const valid = result.data.find((item) => item.attributes.processingState === "VALID");
+  const build = valid ?? result.data[0];
+  return build ? { id: build.id, attributes: build.attributes } : null;
+}
+async function findLocalization(client, versionId, locale) {
+  const result = await client.get(
+    `/appStoreVersions/${versionId}/appStoreVersionLocalizations`
+  );
+  const match = result.data.find((item) => item.attributes.locale === locale);
+  return match ? { id: match.id, attributes: match.attributes } : null;
+}
+async function createReviewSubmission(client, appId) {
+  const created = await client.post("/reviewSubmissions", {
+    data: {
+      type: "reviewSubmissions",
+      attributes: { platform: "IOS" },
+      relationships: { app: { data: { id: appId, type: "apps" } } }
+    }
+  });
+  return { id: created.data.id, attributes: created.data.attributes };
+}
+
+// src/release/promote.ts
+function notesByLocale(ctx, config, version, target) {
+  const result = {};
+  for (const locale of config.locales) {
+    const path = notesFilePath(ctx.appDir, config.notesDir, version, locale, target);
+    result[locale] = readNotesFile(path);
+  }
+  return result;
+}
+async function promoteRelease2(ctx, config, opts) {
+  const channel = channelOf(config, opts.channel);
+  assertChannelOptIn(ctx, config, channel, opts);
+  const version = readAppVersion(ctx.appDir, config);
+  const result = {};
+  const wantsAndroid = (!opts.platform || opts.platform === "android") && channel.android;
+  const wantsIos = (!opts.platform || opts.platform === "ios") && channel.ios;
+  if (!wantsAndroid && !wantsIos) fail("nenhuma plataforma configurada no canal para promover.");
+  if (ctx.dryRun) {
+    if (wantsAndroid) ctx.log.info(`[dry-run] Play: promover ${channel.android.testTrack} \u2192 ${channel.android.productionTrack} (${channel.android.package})`);
+    if (wantsIos) ctx.log.info(`[dry-run] Apple: criar Review Submission para ${channel.ios.bundleId} v${version}`);
+    return result;
+  }
+  if (wantsAndroid) {
+    const android = channel.android;
+    const google = createGoogleClient(ctx.env);
+    try {
+      const notes = notesByLocale(ctx, config, version, "play");
+      ctx.log.step(`Play: promovendo ${android.testTrack} \u2192 ${android.productionTrack}`);
+      const release = await promoteRelease(google, {
+        packageName: android.package,
+        fromTrack: android.testTrack,
+        toTrack: android.productionTrack,
+        notesByLocale: notes,
+        initialRollout: android.initialRollout
+      });
+      ctx.log.success(`Play: ${android.productionTrack} status=${release.status} versionCodes=${(release.versionCodes ?? []).join(",")}`);
+      result.android = { versionCodes: release.versionCodes, status: release.status };
+    } finally {
+      google.cleanup();
+    }
+  }
+  if (wantsIos) {
+    const ios = channel.ios;
+    const apple = createAppleClient(ctx.env);
+    try {
+      const notes = notesByLocale(ctx, config, version, "ios");
+      ctx.log.step(`Apple: enviando Review Submission para ${ios.bundleId} v${version}`);
+      const submission = await submitForReview(apple, {
+        bundleId: ios.bundleId,
+        versionString: version,
+        whatsNewByLocale: notes,
+        automaticRelease: ios.automaticRelease,
+        phasedRelease: ios.phasedRelease,
+        copyright: ios.copyright
+      });
+      if (submission.alreadyInProgress) {
+        ctx.log.warn(`Apple: j\xE1 existe submission em an\xE1lise (${submission.submissionId}, state=${submission.state}).`);
+      } else {
+        ctx.log.success(`Apple: submission ${submission.submissionId} enviada (state=${submission.state}).`);
+      }
+      result.ios = { submissionId: submission.submissionId, state: submission.state, alreadyInProgress: submission.alreadyInProgress };
+    } finally {
+      apple.cleanup();
+    }
+  }
+  return result;
+}
+
+// src/release/rollout.ts
+async function rolloutRelease(ctx, config, opts) {
+  if (opts.platform !== "android") {
+    fail("rollout percentual s\xF3 \xE9 suportado para Android nesta vers\xE3o. iOS: acompanhe o phased release no App Store Connect.");
+  }
+  const channel = channelOf(config, opts.channel);
+  assertChannelOptIn(ctx, config, channel, opts);
+  if (!channel.android) fail(`canal "${opts.channel}" n\xE3o tem configura\xE7\xE3o android.`);
+  if (ctx.dryRun) {
+    ctx.log.info(`[dry-run] Play: ${channel.android.productionTrack} \u2192 ${opts.to}`);
+    return { dryRun: true };
+  }
+  const google = createGoogleClient(ctx.env);
+  try {
+    const release = await setRollout(google, channel.android.package, channel.android.productionTrack, opts.to);
+    ctx.log.success(`Play: ${channel.android.productionTrack} agora ${release.status}${release.userFraction ? ` (${Math.round(release.userFraction * 100)}%)` : ""}`);
+    return release;
+  } finally {
+    google.cleanup();
+  }
+}
+
+// src/release/status.ts
+async function statusOf(ctx, config, opts) {
+  const channel = channelOf(config, opts.channel);
+  const version = readAppVersion(ctx.appDir, config);
+  const result = { version };
+  if (channel.android) {
+    const google = createGoogleClient(ctx.env);
+    try {
+      const track = await getTrackStatus(google, channel.android.package, channel.android.productionTrack);
+      result.android = {
+        track: channel.android.productionTrack,
+        releases: (track.releases ?? []).map((release) => ({
+          status: release.status,
+          versionCodes: release.versionCodes,
+          userFraction: release.userFraction
+        }))
+      };
+    } finally {
+      google.cleanup();
+    }
+  }
+  if (channel.ios) {
+    const apple = createAppleClient(ctx.env);
+    try {
+      const status = await getIosStatus(apple, channel.ios.bundleId, version);
+      result.ios = { appStoreState: status.appStoreState, reviewSubmissionState: status.reviewSubmissionState };
+    } finally {
+      apple.cleanup();
+    }
+  }
+  return result;
+}
+
+// src/release/update.ts
+function updateRelease(ctx, config, opts) {
+  const channel = channelOf(config, opts.channel);
+  assertChannelOptIn(ctx, config, channel, opts);
+  if (!channel.ota) {
+    fail(`canal "${opts.channel}" n\xE3o tem "ota.channel" configurado.`);
+  }
+  if (ctx.dryRun) {
+    const command = formatCommand("eas", ["update", "--channel", channel.ota.channel, "--message", opts.message ?? "(sem mensagem)"], channel.env);
+    ctx.log.info(`[dry-run] cd ${ctx.appDir} && ${command}`);
+    return { dryRun: true, command, channel: channel.ota.channel };
+  }
+  ctx.log.step(`eas update (channel ${channel.ota.channel})`);
+  requireSuccess(
+    easUpdate(ctx, { channel: channel.ota.channel, message: opts.message, platform: opts.platform, env: channel.env }),
+    "eas update"
+  );
+  return { channel: channel.ota.channel };
+}
+export {
+  APPLE_WHATS_NEW_MAX,
+  PLAY_NOTES_MAX,
+  assertChannelOptIn,
+  assertNotesWithinLimit,
+  buildRelease,
+  bumpVersion,
+  channelOf,
+  checkGitPolicy,
+  commitsSinceLastTag,
+  configExists,
+  createAppStoreConnectToken,
+  createContext,
+  draftAndEditNotes,
+  draftNotes,
+  fetchAccessToken,
+  loadConfig,
+  nextVersion,
+  notesMaxFor,
+  parseConfig,
+  parseServiceAccountJson,
+  promoteRelease2 as promoteRelease,
+  protectedChannelNames,
+  readAppVersion,
+  releaseKitConfigSchema,
+  rolloutRelease,
+  runDoctor,
+  shipRelease,
+  statusOf,
+  submitRelease,
+  updateRelease,
+  userFacingCommits,
+  writeAppVersion,
+  writeConfig
+};
+//# sourceMappingURL=index.js.map