EAS Update: каналы, ветки и вес обновления

# публикация: бандл собирается и уезжает в конец ветки
eas update --branch release-1.0 --message "таймер отдыха 90 секунд"

# канал переключается на другую ветку — без пересборки и без магазина
eas channel:edit production --branch hotfix-1.0

// в подложке: разбор ответа из прошлых статей, ветки «Подхода» и каналы с их правилами
interface Published { id: string; createdAt: string; runtimeVersion: string; platform: string }
interface Channel { branchMapping: { version: number; data: { branchId: string; branchMappingLogic: unknown }[] } }
declare const branches: Record<string, Published[]>;
declare const channels: Record<string, Channel>;
declare function multipartResponse(parts: { name: string; body: unknown }[]): Response;
declare function readManifest(res: Response): Promise<Published | null>;

const noUpdate = (): Response => new Response(null, { status: 204, headers: { "expo-protocol-version": "1" } });

// правило канала: одна запись с логикой "true" — весь канал смотрит в одну ветку
function branchForChannel(name: string): string | null {
  const channel = channels[name];
  if (!channel) return null;
  const entry = channel.branchMapping.data.find((e) => e.branchMappingLogic === "true");
  return entry ? entry.branchId : null;
}

async function updateServer(request: Request): Promise<Response> {
  const runtimeVersion = request.headers.get("expo-runtime-version");
  const platform = request.headers.get("expo-platform");
  const channel = request.headers.get("expo-channel-name");
  const branch = channel === null ? null : branchForChannel(channel);
  if (!runtimeVersion || !platform || branch === null) return noUpdate();
  const fits = (branches[branch] ?? []).filter((u) => u.runtimeVersion === runtimeVersion && u.platform === platform);
  if (fits.length === 0) return noUpdate();
  return multipartResponse([{ name: "manifest", body: fits.reduce((a, b) => (b.createdAt > a.createdAt ? b : a)) }]);
}

async function ask(channel: string): Promise<void> {
  const headers = { "expo-platform": "android", "expo-runtime-version": "1.0.0", "expo-channel-name": channel };
  const res = await updateServer(new Request("https://u.expo.dev/podhod", { headers }));
  const update = res.status === 200 ? await readManifest(res) : null;
  console.log(channel, "→", branchForChannel(channel) ?? "канала нет", "→", update ? update.id : "обновления нет");
}

(async () => {
  for (const name of ["production", "preview", "development"]) await ask(name);
  // eas channel:edit production --branch hotfix-1.0: меняется только правило канала
  channels.production.branchMapping.data = [{ branchId: "hotfix-1.0", branchMappingLogic: "true" }];
  await ask("production");
})();

npx expo export --platform android

// metadata.json из dist, сокращённый: 27 ассетов свёрнуты до двух
{
  "version": 0,
  "bundler": "metro",
  "fileMetadata": {
    "android": {
      "bundle": "_expo/static/js/android/entry-358b4e73d2e36ba9d4165f913b957ce3.hbc",
      "assets": [
        { "path": "assets/96032e7aed600e905412ba2e0281f754", "ext": "ttf" },
        { "path": "assets/0a328cd9c1afd0afe8e3b1ec5165b1b4", "ext": "png" }
      ]
    }
  }
}

interface Asset { key: string; bytes: number }
// в подложке: файлы обновления из dist и ключи, которые уже есть на сервере и на телефоне
declare const exported: { bundle: Asset; assets: Asset[] };
declare const onServer: string[];
declare const onPhone: string[];

function bytesOf(list: Asset[]): number {
  return list.reduce((total, a) => total + a.bytes, 0);
}

// eas update грузит ассет, только если сервер не знает его storageKey
function toUpload(server: Set<string>): Asset[] {
  return [exported.bundle, ...exported.assets.filter((a) => !server.has(a.key))];
}

// телефон качает из манифеста всё, чего нет у него самого
function toDownload(phone: Set<string>): Asset[] {
  return [exported.bundle, ...exported.assets].filter((a) => !phone.has(a.key));
}

const all = [exported.bundle, ...exported.assets];
console.log("в обновлении файлов:", all.length, "| байт:", bytesOf(all));

const upload = toUpload(new Set(onServer));
console.log("публикация отправит:", upload.length, "| байт:", bytesOf(upload));
for (const a of upload) console.log("  →", a.key, a.bytes);

const download = toDownload(new Set(onPhone));
console.log("телефон скачает:", download.length, "| байт:", bytesOf(download));
for (const a of download) console.log("  ←", a.key, a.bytes);

# раскатка ветки на канале: 10% установок со сборкой 1.0.0 идут на hotfix-1.0
eas channel:rollout production --action=create --branch hotfix-1.0 --percent 10 --runtime-version 1.0.0

# доля меняется одной командой, ничего не публикуя заново
eas channel:rollout production --action=edit --percent 50

# то же самое, но процентом на самом обновлении, внутри одной ветки
eas update --branch release-1.0 --message "таймер 90 секунд" --rollout-percentage 10

interface Install { clientId: string; runtimeVersion: string }
interface Node { clientKey: string; branchMappingOperator: string; operand: unknown }
type Logic = string | Node | unknown[];
// в подложке: тысяча установок и устойчивое число 0…1 по идентификатору установки
declare const installs: Install[];
declare const channels: Record<string, { branchMapping: { version: number; data: { branchId: string; branchMappingLogic: Logic }[] } }>;
declare function rolloutToken(clientId: string): number;

function evaluateLogic(logic: Logic, install: Install): boolean {
  if (logic === "true") return true;
  if (Array.isArray(logic)) return logic.slice(1).every((node) => evaluateLogic(node as Logic, install));
  const node = logic as Node;
  if (node.clientKey === "runtimeVersion") return install.runtimeVersion === String(node.operand);
  // hash_lt: число установки против порога
  if (node.clientKey === "rolloutToken") return rolloutToken(install.clientId) < Number(node.operand);
  throw new Error("неизвестный ключ " + node.clientKey);
}

function branchFor(install: Install): string {
  const found = channels.production.branchMapping.data.find((e) => evaluateLogic(e.branchMappingLogic, install));
  return found ? found.branchId : "обновлений нет";
}

// eas channel:rollout production --action=create --branch hotfix-1.0 --percent 10 --runtime-version 1.0.0
function setRollout(percent: number): void {
  channels.production.branchMapping = { version: 0, data: [
    { branchId: "hotfix-1.0", branchMappingLogic: ["and",
      { operand: "1.0.0", clientKey: "runtimeVersion", branchMappingOperator: "==" },
      { operand: percent / 100, clientKey: "rolloutToken", branchMappingOperator: "hash_lt" }] },
    { branchId: "release-1.0", branchMappingLogic: "true" },
  ] };
}

function spread(): Record<string, number> {
  const by: Record<string, number> = {};
  for (const install of installs) {
    const branch = branchFor(install);
    by[branch] = (by[branch] ?? 0) + 1;
  }
  return by;
}

setRollout(10);
console.log("10%:", spread());
const first = installs.filter((i) => branchFor(i) === "hotfix-1.0");
setRollout(50);
console.log("50%:", spread());
console.log("из первых", first.length, "выпало:", first.filter((i) => branchFor(i) !== "hotfix-1.0").length);
console.log("inst-7 на сборке 1.0.0:", branchFor({ clientId: "inst-7", runtimeVersion: "1.0.0" }));
console.log("inst-7 на сборке 1.1.0:", branchFor({ clientId: "inst-7", runtimeVersion: "1.1.0" }));

# плохое обновление пришло с другой ветки: вернуть канал на прежнюю
eas channel:edit production --branch release-1.0

# плохое обновление в той же ветке, куда смотрит канал, — нужна новая публикация.
# переиздать прежнюю группу: то же содержимое, новая группа и новое время
eas update:republish --group <id прежней группы> --message "откат таймера"

# или директива «вернуться к тому, что вшито в сборку»
eas update:roll-back-to-embedded --branch release-1.0 --runtime-version 1.0.0 --message "к сборке"

# или пусть выберет команда: переиздаст предыдущую группу ветки, а если её нет — отправит откат к сборке
eas update:rollback <id плохой группы>

# остановить канал совсем
eas channel:pause production

type Metadata = Record<string, string>;
interface Stored { id: string; commitTime: string; metadata?: Metadata }
type Part = { headers: Record<string, string>; body: string };
type Filters = Record<string, string>;
// в подложке: разбор ответа, запущенное обновление и вшитое в сборку
declare const launched: Stored;
declare const embedded: Stored;
declare function multipartResponse(parts: { name: string; body: unknown }[]): Response;
declare function parseMultipart(contentType: string, text: string): Part[];
declare function partNamed(parts: Part[], name: string): Part | undefined;

// заголовок expo-manifest-filters: branchname="release-1.0" — словарь «ключ = строка»
function parseFilters(header: string | null): Filters {
  const filters: Filters = {};
  for (const [, key, value] of (header ?? "").matchAll(/([\w-]+)="([^"]*)"/g)) filters[key] = value;
  return filters;
}

// SelectionPolicies.matchesFilters: ключи metadata сверяются без учёта регистра;
// если ключа в metadata нет (или нет самой metadata), фильтр не мешает
function matchesFilters(update: { metadata?: Metadata }, filters: Filters): boolean {
  const metadata = new Map(Object.entries(update.metadata ?? {}).map(([k, v]) => [k.toLowerCase(), v]));
  return Object.entries(filters).every(([key, value]) => !metadata.has(key) || metadata.get(key) === value);
}

// LoaderSelectionPolicyFilterAware: сначала фильтр ветки, время — только потом
async function decide(res: Response, current: Stored): Promise<string> {
  if (res.status === 204) return "обновления нет";
  const filters = parseFilters(res.headers.get("expo-manifest-filters"));
  const parts = parseMultipart(res.headers.get("content-type") ?? "", await res.text());
  // запущенное не проходит фильтр — оно с другой ветки, и время уже не сравнивают
  const foreign = !matchesFilters(current, filters);
  const manifest = partNamed(parts, "manifest");
  if (manifest) {
    // в манифесте это поле зовётся createdAt, в базе телефона — commitTime
    const update = JSON.parse(manifest.body) as { id: string; createdAt: string; metadata?: Metadata };
    if (!matchesFilters(update, filters)) return "пропустит " + update.id + ": оно не с этой ветки";
    if (foreign) return "скачает " + update.id + ": запущенное с другой ветки, время не сравнивается";
    if (update.createdAt <= current.commitTime) return "пропустит " + update.id + ": оно не новее запущенного";
    return "скачает " + update.id;
  }
  const directive = partNamed(parts, "directive");
  if (!directive) return "нечего делать";
  const body = JSON.parse(directive.body) as { type: string; parameters: { commitTime: string } };
  if (body.type !== "rollBackToEmbedded") return "нечего делать";
  // у вшитого манифеста metadata нет, фильтр ему не помеха
  if (!foreign && body.parameters.commitTime <= current.commitTime) return "пропустит откат: он не новее запущенного";
  return "откатится на вшитое " + embedded.id;
}

// A: upd-0917 пришло с hotfix-1.0 — имя ветки EAS кладёт в metadata манифеста
const phoneA: Stored = { ...launched, metadata: { branchName: "hotfix-1.0" } };
// B — другая история: плохую группу upd-0919 опубликовали прямо в release-1.0
const phoneB: Stored = { id: "upd-0919", commitTime: "2026-09-19T09:00:00.000Z", metadata: { branchName: "release-1.0" } };

const older = { id: "upd-0911", createdAt: "2026-09-11T08:30:00.000Z", metadata: { branchName: "release-1.0" } };
const republished = { id: "upd-0920", createdAt: "2026-09-20T09:00:00.000Z", metadata: { branchName: "release-1.0" } };
const rollBack = { type: "rollBackToEmbedded", parameters: { commitTime: "2026-09-20T10:00:00.000Z" } };
const lateRollBack = { type: "rollBackToEmbedded", parameters: { commitTime: "2026-09-01T10:00:00.000Z" } };

// ответ ветки release-1.0: EAS прикладывает к нему фильтр с именем ветки
function fromRelease(name: string, body: unknown): Response {
  const res = multipartResponse([{ name, body }]);
  res.headers.set("expo-manifest-filters", 'branchname="release-1.0"');
  return res;
}

const answers: [string, Stored, string, unknown][] = [
  ["A, канал вернули на release-1.0", phoneA, "manifest", older],
  ["B, сервер отдал upd-0911 как есть", phoneB, "manifest", older],
  ["B, republish группы upd-0911", phoneB, "manifest", republished],
  ["B, директива отката", phoneB, "directive", rollBack],
  ["B, директива с прежним временем", phoneB, "directive", lateRollBack],
];

(async () => {
  for (const [label, phone, name, body] of answers) {
    console.log(label, "→", await decide(fromRelease(name, body), phone));
  }
})();