Что летит по воздуху, а что требует пересборки

interface Project { config: Record<string, unknown>; files: Record<string, string> }
// модель проекта «Подход» лежит в подложке: config — публичный конфиг, files — дерево файлов
declare const project: Project;

type Where = "бандл" | "бинарник" | "читает сборка";

function whereGoes(path: string, p: Project): Where {
  // package.json, app.config.js и eas.json никуда не едут: их читают инструменты сборки
  if (path.endsWith("package.json") || path === "app.config.js" || path === "eas.json") return "читает сборка";
  if (/(^|\/)(android|ios)\//.test(path)) return "бинарник";
  // картинки, названные в конфиге, prebuild раскладывает по нативным ресурсам
  if (path === String(p.config.icon).replace("./", "")) return "бинарник";
  return "бандл";
}

const buckets: Record<Where, string[]> = { "бандл": [], "бинарник": [], "читает сборка": [] };
for (const path of Object.keys(project.files)) buckets[whereGoes(path, project)].push(path);
for (const [where, list] of Object.entries(buckets)) console.log(where + ":", list.length);

console.log("иконка:", whereGoes("public/icon-512.png", project));
console.log("app.config.js:", whereGoes("app.config.js", project));
console.log("expo-sqlite, JS:", whereGoes("node_modules/expo-sqlite/src/index.ts", project));
console.log("expo-sqlite, натив:", whereGoes("node_modules/expo-sqlite/android/SQLiteModule.kt", project));

npx expo-updates fingerprint:generate --platform android > fingerprint.json

node -e "const fp = require('./fingerprint.json');
  const by = {};
  fp.sources.forEach((s) => s.reasons.forEach((r) => { by[r] = (by[r] || 0) + 1; }));
  console.log('hash:', fp.hash);
  console.log('источников:', fp.sources.length);
  for (const [r, n] of Object.entries(by).sort((a, b) => b[1] - a[1])) console.log(' ', n, r);"

interface Project { config: Record<string, unknown>; files: Record<string, string> }
interface Source { type: "file" | "dir" | "contents"; id: string; reason: string; contents?: string }
declare const project: Project;
// JSON.stringify с отсортированными ключами: перестановка полей в конфиге ничего не значит
declare function stringifySorted(value: unknown): string;

function collectSources(p: Project): Source[] {
  const sources: Source[] = [];
  const packages = new Set<string>();
  for (const path of Object.keys(p.files)) {
    // папки android и ios самого проекта генерирует prebuild — их содержимое не в счёт
    if (path.startsWith("android/") || path.startsWith("ios/")) continue;
    const native = /^(node_modules\/[^/]+)\/(android|ios)\//.exec(path);
    if (native) packages.add(native[1] + "/" + native[2]);
  }
  for (const dir of [...packages].sort()) sources.push({ type: "dir", id: dir, reason: "expoAutolinking" });
  sources.push({ type: "file", id: "eas.json", reason: "easBuild" });
  sources.push({ type: "file", id: String(p.config.icon).replace("./", ""), reason: "expoConfigExternalFile" });
  sources.push({ type: "contents", id: "expoConfig", reason: "expoConfig", contents: stringifySorted(p.config) });
  sources.push({
    type: "contents",
    id: "package:react-native",
    reason: "package:react-native",
    contents: p.files["node_modules/react-native/package.json"],
  });
  return sources;
}

const sources = collectSources(project);
for (const s of sources) console.log(s.type, s.id, "←", s.reason);
const mine = sources.filter((s) => s.id.startsWith("app/") || s.id.startsWith("src/"));
console.log("источников:", sources.length, "| из них ваш JS:", mine.length);

interface Project { config: Record<string, unknown>; files: Record<string, string> }
interface Source { type: "file" | "dir" | "contents"; id: string; reason: string; contents?: string }
declare const project: Project;
declare function collectSources(p: Project): Source[];
// SHA-1 в hex: тот же алгоритм и та же запись, что у @expo/fingerprint
declare function sha1(text: string): Promise<string>;

async function hashOf(p: Project, s: Source): Promise<string> {
  if (s.type === "contents") return sha1(s.contents ?? "");
  // у папки хеш складывается из имён и хешей её файлов, имена — по порядку
  const paths = Object.keys(p.files).filter((f) => f === s.id || f.startsWith(s.id + "/")).sort();
  const parts = await Promise.all(paths.map(async (f) => f + (await sha1(p.files[f]))));
  return sha1(parts.join(""));
}

const typeOrder = { file: 0, dir: 1, contents: 2 };

async function fingerprintOf(p: Project): Promise<{ hash: string; sources: (Source & { hash: string })[] }> {
  const sources = await Promise.all(collectSources(p).map(async (s) => ({ ...s, hash: await hashOf(p, s) })));
  // порядок обхода файлов на разных машинах разный, поэтому набор сортируется
  sources.sort((a, b) => typeOrder[a.type] - typeOrder[b.type] || a.id.localeCompare(b.id));
  return { hash: await sha1(sources.map((s) => s.id + s.hash).join("")), sources };
}

(async () => {
  const fp = await fingerprintOf(project);
  for (const s of fp.sources) console.log(s.hash.slice(0, 8), s.type, s.id);
  console.log("отпечаток:", fp.hash);
  // тот же проект, но файлы перечислены в обратном порядке
  const reversed: Project = { ...project, files: Object.fromEntries(Object.entries(project.files).reverse()) };
  console.log("он же, файлы в другом порядке:", (await fingerprintOf(reversed)).hash);
})();

interface Project { config: Record<string, unknown>; files: Record<string, string> }
declare const project: Project;
declare function fingerprintOf(p: Project): Promise<{ hash: string }>;
// копии проекта с правками; null в patch удаляет файл
declare function withFiles(p: Project, patch: Record<string, string | null>): Project;
declare function withConfig(p: Project, patch: Record<string, unknown>): Project;

const changes: [string, Project][] = [
  ["таймер отдыха 90 секунд", withFiles(project, { "app/(tabs)/rest.tsx": "таймер отдыха: 90 секунд" })],
  ["react 19.2.1 в package.json", withFiles(project, { "package.json": "зависимости: react 19.2.1, expo 57.0.16" })],
  ["react-native 0.86.1", withFiles(project, { "node_modules/react-native/package.json": "react-native 0.86.1" })],
  ["expo-haptics: вибрация", withFiles(project, {
    "node_modules/expo-haptics/src/index.ts": "вибрация: JS-половина",
    "node_modules/expo-haptics/android/HapticsModule.kt": "вибрация: натив",
  })],
  ["version 1.0.1 в конфиге", withConfig(project, { version: "1.0.1" })],
  ["правка в android/app/build.gradle", withFiles(project, { "android/app/build.gradle": "поправлено руками" })],
];

(async () => {
  const before = (await fingerprintOf(project)).hash;
  console.log("отпечаток сборки:", before.slice(0, 8));
  for (const [name, after] of changes) {
    const hash = (await fingerprintOf(after)).hash;
    console.log(hash === before ? "долетит:" : "нужна сборка:", name, hash.slice(0, 8));
  }
})();

// fingerprint.config.js: поднятая версия натива не меняет — пусть не меняет и отпечаток
module.exports = {
  sourceSkips: ["ExpoConfigVersions", "ExpoConfigRuntimeVersionIfString"],
};

npx @expo/fingerprint fingerprint:diff before.json after.json \
  | node -e "let s = '';
      process.stdin.on('data', (d) => (s += d)).on('end', () => {
        for (const d of JSON.parse(s)) {
          const src = d.beforeSource || d.addedSource || d.removedSource;
          console.log(d.op, src.type, src.id || src.filePath, d.beforeSource.hash, '->', d.afterSource.hash);
        }
      });"

interface Project { config: Record<string, unknown>; files: Record<string, string> }
interface Published { id: string; createdAt: string; runtimeVersion: string; platform: string }
interface Phone { name: string; modules: string[]; project: Project }
declare const project: Project;
declare function fingerprintOf(p: Project): Promise<{ hash: string }>;
declare function withFiles(p: Project, patch: Record<string, string | null>): Project;
// всё из прошлых статей: сервер со сверкой runtimeVersion, чтение манифеста, реестр модулей
declare const published: Published[];
declare function updateServer(request: Request): Promise<Response>;
declare function readManifest(res: Response): Promise<Published | null>;
declare function installBuild(modules: string[]): void;
declare function finishRest(): Promise<string>;

const withHaptics = withFiles(project, {
  "node_modules/expo-haptics/src/index.ts": "вибрация: JS-половина",
  "node_modules/expo-haptics/android/HapticsModule.kt": "вибрация: натив",
});
const restTimer90 = withFiles(project, { "app/(tabs)/rest.tsx": "таймер отдыха: 90 секунд" });
const updateJs: Record<string, () => Promise<string>> = {
  "upd-1001": () => finishRest(),
  "upd-1002": async () => "таймер отдыха 90 секунд",
};

async function launch(phone: Phone): Promise<void> {
  const runtimeVersion = (await fingerprintOf(phone.project)).hash;
  const headers = { "expo-platform": "android", "expo-runtime-version": runtimeVersion };
  const res = await updateServer(new Request("https://updates.podhod.example/manifest", { headers }));
  const update = res.status === 200 ? await readManifest(res) : null;
  installBuild(phone.modules);
  const who = `${phone.name} (${runtimeVersion.slice(0, 8)})`;
  if (!update) return console.log(`${who}: обновления нет`);
  const done = await updateJs[update.id]().catch((err: { code?: string }) => err.code ?? "ошибка");
  console.log(`${who}: ${update.id} → ${done}`);
}

const storeBuild: Phone = { name: "сборка из магазина", modules: [], project };
const hapticsBuild: Phone = { name: "сборка с вибрацией", modules: ["ExpoHaptics"], project: withHaptics };

(async () => {
  const publish = async (id: string, createdAt: string, p: Project): Promise<void> => {
    published.push({ id, createdAt, runtimeVersion: (await fingerprintOf(p)).hash, platform: "android" });
  };
  // обновление с вибрацией собрано на проекте, где expo-haptics есть: его отпечаток и попал в манифест
  await publish("upd-1001", "2026-10-01T10:00:00.000Z", withHaptics);
  await launch(storeBuild);
  await launch(hapticsBuild);
  // а это правка одного экрана
  await publish("upd-1002", "2026-10-02T10:00:00.000Z", restTimer90);
  await launch(storeBuild);
})();