fullstack-gates 0.1.0

package/scripts/check-proto-ids.ts

@@ -0,0 +1,199 @@
+/**
+ * `bun run check:proto-ids` — ЧЕМ ПРИЛОЖЕНИЕ АДРЕСУЕТ СУЩНОСТИ В ССЫЛКАХ.
+ *
+ * ПРАВИЛО: **ни одна ссылка, по которой человек может кликнуть, не содержит выдуманного
+ * идентификатора.** Идентичность приходит из модели данных — первичный ключ базы. Строка из
+ * вёрстки (`c-mkt`, `r-smm`, `m-kim`) ключом не является ни на одном слое, и в адресе — тоже.
+ *
+ * ПОЧЕМУ ГЕЙТ, А НЕ ЗАМЕТКА. Нашёл это не тест и не ревью, а владелец: «нажимаю создать круг и
+ * выходит `/circles/new?parent_circle_id=c-mkt`; и сама ссылка из меню ведёт на
+ * `/circles/c-company`». Ни один уровень поймать не мог:
+ *
+ *   • юнит и интеграция проверяют СЕРВЕР — он про ссылки клиента не знает ничего;
+ *   • переводчик адресов (`protoHref`) переписывает ИМЯ ФАЙЛА прототипа в маршрут приложения и
+ *     пропускает параметры насквозь: `circle-detail.html?circle_id=c-mkt` становится
+ *     `/circles/c-mkt` — то есть выглядит маршрутом приложения и им не является;
+ *   • сверка с прототипом ходит по тем же выдуманным адресам и потому ЗЕЛЕНА на них: оракул и
+ *     дефект согласованы между собой.
+ *
+ * Наружу это выходит как «приложение не работает»: страница открывается, показывает перенесённую
+ * вёрстку, а сервер на этот адрес отвечает «нет такой записи». Между настоящим ключом и настоящей
+ * разметкой лежит АДРЕС, и не проверял его никто.
+ *
+ * ЧТО СЧИТАЕТСЯ — ВЫХОД, А НЕ ВХОД.
+ *
+ * Разметка прототипа обязана оставаться прототипной: она правится перегенерацией, и выдуманные
+ * адреса в ней — свойство источника, а не дефект. Считать их значило бы мерить вход и получить
+ * число, которое нельзя свести к нулю, не сломав перенос.
+ *
+ * Поэтому берётся КАЖДЫЙ адрес перенесённых экранов и прогоняется через переводчик приложения.
+ * Долг — это адреса, у которых нет настоящего ключа: человек по ним кликает и попадает в
+ * объявленное «данных нет». Число падает ровно тогда, когда экран научился настоящей идентичности,
+ * и не падает от косметики.
+ *
+ * РЕЖИМ ХРАПОВИКА: базовая линия пишется один раз (`--write`), рост роняет прогон, снижение требует
+ * поправить число — список, который не обязан быть точным, за месяц становится украшением.
+ *
+ * ЧЕГО ГЕЙТ НЕ ДЕЛАЕТ. Он не проверяет, что настоящий ключ СУЩЕСТВУЕТ в базе — это работа e2e на
+ * живом стенде. Здесь проверяется: приложение вообще способно собрать этот адрес или нет.
+ */
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+
+/**
+ * Корень РЕПЫ, а не скрипта.
+ *
+ * Скрипт живёт в плагине и запускается из репы (`bun run "$CLAUDE_PLUGIN_ROOT/assets/scripts/…"`),
+ * поэтому свой собственный путь корнем быть не может: он указал бы внутрь плагина, гейт обошёл бы
+ * чужое дерево и объявил «нарушений нет» — зелёный на пустоте. Рабочий каталог задаёт `bun run`,
+ * и он всегда корень пакета; путь скрипта остаётся запасным для случая, когда файл всё-таки
+ * скопирован в репу.
+ */
+const ROOT = existsSync(join(process.cwd(), "package.json"))
+  ? resolve(process.cwd())
+  : resolve(import.meta.dir, "..");
+const ALLOW_FILE = join(ROOT, "scripts/proto-ids.allow");
+const write = Bun.argv.includes("--write");
+
+const SEARCH_ROOTS = ["packages", "apps", "src"];
+const KEEP = (rel: string) => /\/(ui|client)\//.test(rel) && /\.tsx?$/.test(rel);
+
+const files: string[] = [];
+function walk(dir: string) {
+  if (!existsSync(dir)) return;
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (["node_modules", "dist", "build", ".turbo"].includes(entry.name)) continue;
+      walk(full);
+    } else if (KEEP(full.split("\\").join("/"))) files.push(full);
+  }
+}
+for (const dir of SEARCH_ROOTS) walk(join(ROOT, dir));
+
+/**
+ * Переводчик ищется по имени, а не импортируется путём: раскладка клиента у каждой репы своя, а
+ * договорённость одна — единственное место, где рождается адрес.
+ */
+const translator = files.find((f) => /\/proto-href\.tsx?$/.test(f.split("\\").join("/")));
+if (!translator) {
+  console.error(
+    `\nОШИБКА: не найден переводчик адресов (*/proto-href.ts). Гейт не отработал — проверь раскладку.`
+  );
+  process.exit(1);
+}
+const { protoHref, UNAVAILABLE } = (await import(translator)) as {
+  protoHref: (raw: string, subs?: Record<string, string | undefined>) => string;
+  UNAVAILABLE: string;
+};
+
+type Hit = { file: string; href: string; to: string };
+const hits: Hit[] = [];
+const seen = new Set<string>();
+for (const file of files) {
+  const rel = relative(ROOT, file).split("\\").join("/");
+  if (/proto-href\.(test\.)?tsx?$/.test(rel)) continue;
+  /**
+   * Комментарии вырезаются ДО поиска — то же правило, что у `check:proto` и `check:write-path`:
+   * файл, который ОБЪЯСНЯЕТ выдуманный адрес, содержит эту строку и выглядел бы дефектом.
+   */
+  const source = readFileSync(file, "utf8")
+    .replace(/\/\*[\s\S]*?\*\//g, (m) => m.replace(/[^\n]/g, " "))
+    .replace(/(^|[^:"'`])\/\/[^\n]*/g, (m, head) => head + " ".repeat(m.length - head.length));
+  for (const m of source.matchAll(/["'`]([a-z0-9-]+\.html(?:\?[^"'`]*)?)["'`]/g)) {
+    const href = m[1]!;
+    if (href.includes("${")) continue;
+    const key = `${rel}|${href}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    hits.push({ file: rel, href, to: protoHref(href) });
+  }
+}
+
+const dead = hits.filter((h) => h.to === UNAVAILABLE);
+const byFile = new Map<string, number>();
+for (const h of dead) byFile.set(h.file, (byFile.get(h.file) ?? 0) + 1);
+
+if (write) {
+  const body = [
+    "# АДРЕС БЕЗ НАСТОЯЩЕГО КЛЮЧА — объявленный ДОЛГ, а не разрешение.",
+    "#",
+    "# Каждая строка: <файл> <число адресов>. По такому адресу человек кликает и попадает в",
+    "# объявленное «данных нет»: экран ещё не знает настоящей идентичности той записи.",
+    "#",
+    "# Список СОКРАЩАЕТСЯ по мере того, как экраны получают настоящие ключи. Уменьшилось число —",
+    "# правь строку; стало ноль — удаляй её.",
+    "#",
+    `# Записано ${byFile.size} файлов, ${dead.length} адресов из ${hits.length}.`,
+    "",
+    ...[...byFile.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([f, n]) => `${f} ${n}`),
+    "",
+  ].join("\n");
+  Bun.write(ALLOW_FILE, body);
+  console.log(`\nбазовая линия записана: ${dead.length} адресов из ${hits.length}\n`);
+  process.exit(0);
+}
+
+const declared = new Map<string, number>();
+if (existsSync(ALLOW_FILE)) {
+  for (const line of readFileSync(ALLOW_FILE, "utf8").split("\n")) {
+    const text = line.split("#")[0]!.trim();
+    if (!text) continue;
+    const at = text.lastIndexOf(" ");
+    declared.set(text.slice(0, at), Number(text.slice(at + 1)));
+  }
+}
+
+console.log(`\n=== АДРЕСА БЕЗ НАСТОЯЩЕГО КЛЮЧА ===`);
+
+/** Ноль собранных адресов — не «чисто», а не отработавший гейт. */
+if (hits.length === 0) {
+  console.error(
+    `\nОШИБКА: не собрано ни одного адреса (файлов экранов ${files.length}). Гейт не отработал.`
+  );
+  process.exit(1);
+}
+
+console.log(
+  `Адресов в экранах: ${hits.length} · собирается настоящий: ${hits.length - dead.length} · долг: ${dead.length}`
+);
+
+const fresh: string[] = [];
+const grown: string[] = [];
+const stale: string[] = [];
+for (const [file, n] of byFile) {
+  const was = declared.get(file);
+  if (was === undefined) fresh.push(`${file} ${n}`);
+  else if (n > was) grown.push(`${file}: было ${was}, стало ${n}`);
+}
+for (const [file, was] of declared) {
+  const now = byFile.get(file) ?? 0;
+  if (now === 0) stale.push(`${file} (было ${was}, стало 0)`);
+  else if (now < was) stale.push(`${file}: было ${was}, стало ${now} — поправь число`);
+}
+
+if (fresh.length) {
+  console.error(`\nНОВЫЙ адрес без ключа:\n`);
+  for (const f of fresh) console.error(`  ${f}`);
+  for (const h of dead.filter((x) => fresh.some((f) => f.startsWith(`${x.file} `)))) {
+    console.error(`    ${h.file}  ${h.href}`);
+  }
+}
+if (grown.length) {
+  console.error(`\nДОЛГ ВЫРОС:\n`);
+  for (const g of grown) console.error(`  ${g}`);
+}
+if (stale.length) {
+  console.error(`\nЗАПИСЬ ДОЛГА УСТАРЕЛА — поправь ${relative(ROOT, ALLOW_FILE)}:\n`);
+  for (const s of stale) console.error(`  ${s}`);
+}
+
+if (fresh.length || grown.length || stale.length) {
+  console.error(
+    `\nПроверка провалена: новых ${fresh.length}, выросших ${grown.length}, устаревших ${stale.length}.`
+  );
+  process.exit(1);
+}
+
+console.log(`Новых адресов без ключа нет. Объявленный долг: ${dead.length} адресов.\n`);
+process.exit(0);

package/scripts/check-prototype-boundary.ts

@@ -0,0 +1,153 @@
+/**
+ * `bun run check:proto` — граница прототипа.
+ *
+ * ПРАВИЛО: **прототип — это внешний вид, а не данные.** Всё, что извлечено из вёрстки
+ * (`*.gen.ts`), — источник РАЗМЕТКИ, и дальше слоя представления не идёт. Домен, роуты,
+ * composition, сид и тесты идентичности берут из модели данных: первичный ключ базы, а не строку,
+ * которую кто-то придумал в HTML.
+ *
+ * ПОЧЕМУ ГЕЙТ, А НЕ АБЗАЦ В ИНСТРУКЦИИ. Это правило нарушается не по злому умыслу, а потому что в
+ * момент переноса экрана данных ещё нет, а строка `m-kim` в разметке уже есть — и она выглядит как
+ * готовый идентификатор. Инструкцию, которую надо ВСПОМНИТЬ, следующая сессия не вспомнит: она
+ * начнётся с чистого контекста и повторит ровно то же «очевидное» решение. Правило, которое должно
+ * держаться, обязано падать само.
+ *
+ * ЧТО БЫВАЕТ, ЕСЛИ НЕ ДЕРЖАТЬ. Выдуманный id уезжает в порт, из порта в агрегат, из агрегата в
+ * ответ сервера, из ответа — в привязку экрана. Дальше он становится ключом, по которому «работает»
+ * приложение, и подменить его настоящим уже нельзя без переписывания всех четырёх слоёв сразу.
+ * Приложение при этом ЗЕЛЁНОЕ: сценарии сверяют его же выдумку с ней же самой.
+ *
+ * РЕЖИМ ХРАПОВИКА. Объявленные нарушения перечислены в `scripts/prototype-boundary.allow` — это
+ * ДОЛГ, а не разрешение. Новое нарушение роняет прогон. Запись, которая больше не нарушает, тоже
+ * роняет прогон: список, который нельзя сократить, за месяц превращается в фольклор.
+ */
+import { readdirSync, readFileSync, existsSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+
+/**
+ * Корень РЕПЫ, а не скрипта.
+ *
+ * Скрипт живёт в плагине и запускается из репы (`bun run "$CLAUDE_PLUGIN_ROOT/assets/scripts/…"`),
+ * поэтому свой собственный путь корнем быть не может: он указал бы внутрь плагина, гейт обошёл бы
+ * чужое дерево и объявил «нарушений нет» — зелёный на пустоте. Рабочий каталог задаёт `bun run`,
+ * и он всегда корень пакета; путь скрипта остаётся запасным для случая, когда файл всё-таки
+ * скопирован в репу.
+ */
+const ROOT = existsSync(join(process.cwd(), "package.json"))
+  ? resolve(process.cwd())
+  : resolve(import.meta.dir, "..");
+const ALLOW_FILE = join(ROOT, "scripts/prototype-boundary.allow");
+
+/** Где извлечённой вёрстке жить МОЖНО: слой представления и оболочка клиента. */
+const PRESENTATION = [/\/ui\//, /\/client\//];
+
+/**
+ * Где искать. Раскладка бывает разной (монорепо `packages/`+`apps/`, одиночный `src/`), поэтому
+ * берутся все существующие — а не одна угаданная. Ни одного каталога не нашлось → это отказ ниже,
+ * а не пустой зелёный прогон.
+ */
+const SCAN = ["packages", "apps", "src", "lib", "server", "app"];
+const SKIP_DIRS = new Set(["node_modules", "dist", "build", ".turbo"]);
+
+const files: string[] = [];
+function walk(dir: string) {
+  if (!existsSync(dir)) return;
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      if (SKIP_DIRS.has(entry.name)) continue;
+      walk(join(dir, entry.name));
+    } else if (/\.tsx?$/.test(entry.name)) {
+      files.push(join(dir, entry.name));
+    }
+  }
+}
+for (const dir of SCAN) walk(join(ROOT, dir));
+
+/** `import ... from "x.gen.ts"`, `export ... from "x.gen.ts"`, `import("x.gen.ts")`. */
+const SPEC = /(?:\bfrom\s+|\bimport\s*\(\s*|\bimport\s+)["']([^"']+)["']/g;
+const IS_GEN = /\.gen(\.tsx?)?$/;
+
+type Violation = { file: string; line: number; spec: string };
+const found: Violation[] = [];
+
+for (const file of files) {
+  const rel = relative(ROOT, file).split("\\").join("/");
+  if (PRESENTATION.some((re) => re.test(`/${rel}`))) continue;
+  // Сам извлечённый файл собой не нарушает: он и есть разметка.
+  if (IS_GEN.test(rel.replace(/\.tsx?$/, ""))) continue;
+
+  // Комментарии вырезаются ДО поиска, иначе гейт краснеет на собственном объяснении: файл, который
+  // рассказывает, почему он больше не читает `./x.gen.ts`, содержит эту строку — и выглядит
+  // нарушителем. Ложное срабатывание здесь опаснее пропуска: гейт, который врёт, отключают.
+  const source = readFileSync(file, "utf8").replace(/\/\*[\s\S]*?\*\//g, (m) =>
+    m.replace(/[^\n]/g, " ")
+  );
+  const lines = source.split("\n");
+  lines.forEach((raw, i) => {
+    const code = raw.split("//")[0] ?? "";
+    let m: RegExpExecArray | null;
+    SPEC.lastIndex = 0;
+    while ((m = SPEC.exec(code)) !== null) {
+      const spec = m[1]!;
+      if (IS_GEN.test(spec.replace(/\.tsx?$/, ""))) {
+        found.push({ file: rel, line: i + 1, spec });
+      }
+    }
+  });
+}
+
+/** Объявленный долг: одна строка — один файл-нарушитель. Комментарии и пустые строки игнорируются. */
+const declared = existsSync(ALLOW_FILE)
+  ? new Set(
+      readFileSync(ALLOW_FILE, "utf8")
+        .split("\n")
+        .map((l) => l.split("#")[0]!.trim())
+        .filter(Boolean)
+    )
+  : new Set<string>();
+
+const offenders = new Set(found.map((v) => v.file));
+const fresh = found.filter((v) => !declared.has(v.file));
+const stale = [...declared].filter((f) => !offenders.has(f));
+
+console.log(`\n=== ГРАНИЦА ПРОТОТИПА ===`);
+console.log(`Проверено файлов: ${files.length}`);
+
+/**
+ * Ноль просмотренных файлов — это НЕ «нарушений нет». Это гейт, который не отработал: не тот
+ * корень, переехавшая раскладка, запуск не из той директории. Зелёный при нулевом счёте — та же
+ * ложь, что и вручную поставленная галочка, только дешевле в исполнении.
+ */
+if (files.length === 0) {
+  console.error(
+    `\nОШИБКА: не просмотрено ни одного файла — искали в ${SCAN.join(", ")} от ${ROOT}.` +
+      `\nГейт не отработал. Проверь корень репозитория и раскладку исходников.`
+  );
+  process.exit(1);
+}
+console.log(
+  `Файлов с импортом *.gen вне представления: ${offenders.size} (объявлено ${declared.size})`
+);
+
+if (fresh.length) {
+  console.error(`\nНОВОЕ нарушение границы — извлечённая вёрстка ушла за пределы ui/:\n`);
+  for (const v of fresh) console.error(`  ${v.file}:${v.line}  ← ${v.spec}`);
+  console.error(
+    `\nПрототип — это внешний вид. Идентичность и данные берутся из модели данных (PK базы),` +
+      `\nа не из строк вёрстки. Либо перенеси чтение в персистентность, либо оставь ` +
+      `\nизвлечённое в ui/**.`
+  );
+}
+
+if (stale.length) {
+  console.error(`\nЗАПИСЬ ДОЛГА БОЛЬШЕ НЕ НУЖНА — удали её из ${relative(ROOT, ALLOW_FILE)}:\n`);
+  for (const f of stale) console.error(`  ${f}`);
+}
+
+if (fresh.length || stale.length) {
+  console.error(`\nПроверка провалена: новых ${fresh.length}, протухших записей ${stale.length}.`);
+  process.exit(1);
+}
+
+console.log(`Новых нарушений нет. Объявленный долг: ${declared.size} файлов.\n`);
+process.exit(0);

package/scripts/check-screen-wiring.ts

@@ -0,0 +1,312 @@
+#!/usr/bin/env bun
+/**
+ * ПРОВОДКА ЭКРАНА — то, что лежит между доказанным сервером и проверенной разметкой.
+ *
+ * Три дефекта подряд нашёл ЧЕЛОВЕК, а не прогон, и у всех трёх одна форма: сервер прав, разметка
+ * на месте, а между ними обрыв, которого не видит ни один уровень.
+ * Юнит и интеграция зовут сервер напрямую; `check:write-path` смотрит ТОЛЬКО пишущие эндпоинты;
+ * оракул разметки согласен с прототипом по построению. Провод не проверяет никто.
+ *
+ * Здесь проверяется ровно он, четырьмя признаками. Каждый — из УЖЕ СЛУЧИВШЕГОСЯ дефекта, а не
+ * придуман: признак, под который нет своего провала, ловит выдуманную болезнь и первым отключается.
+ *
+ *   1. МЁРТВЫЙ ПРОП-КОЛЛБЭК. `onQuery` объявлен в типе, композиция его передаёт, экран не зовёт
+ *      НИ РАЗУ. Набранное в поле никуда не уходило.
+ *   2. МЁРТВЫЙ ПРОП-ЗНАЧЕНИЕ. `query` объявлен и не читается: экран брал запрос из `defaultValue`
+ *      перенесённой вёрстки и показывал прототипное «ко».
+ *   3. ДУБЛЬ ХВАТАЛКИ. Один `id`/`data-testid` на двух узлах: `id="q"` был и в оболочке, и на
+ *      экране поиска, и `label` подписывал чужое поле; `nb-<id>` делили круг и роль.
+ *      Сценарий, адресующий такой узел, берёт произвольный.
+ *   4. ЧИТАЮЩИЙ ЭНДПОИНТ БЕЗ ВЫЗЫВАЮЩЕГО. `check:write-path` покрывает только мутации; экран,
+ *      который ничего не читает, показывает выдумку и выглядит работающим.
+ *
+ * РЕЖИМ ХРАПОВИКА: базовая линия в `scripts/screen-wiring.allow`, пишется `--write`. Рост роняет
+ * прогон, снижение требует поправить число — список обязан СОКРАЩАТЬСЯ.
+ */
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+
+const ROOT = existsSync(join(process.cwd(), "package.json"))
+  ? resolve(process.cwd())
+  : resolve(import.meta.dir, "..");
+const ALLOW = join(ROOT, "scripts/screen-wiring.allow");
+const write = Bun.argv.includes("--write");
+const verbose = Bun.argv.includes("--details");
+
+const SKIP = new Set(["node_modules", "dist", "build", ".turbo", ".next", "coverage"]);
+const files: string[] = [];
+const walk = (dir: string) => {
+  if (!existsSync(dir)) return;
+  for (const e of readdirSync(dir, { withFileTypes: true })) {
+    const full = join(dir, e.name);
+    if (e.isDirectory()) {
+      if (SKIP.has(e.name)) continue;
+      walk(full);
+    } else if (/\.tsx?$/.test(e.name) && !/\.(test|spec)\./.test(e.name)) files.push(full);
+  }
+};
+for (const d of ["packages", "apps"]) walk(join(ROOT, d));
+
+/** Комментарии вырезаются: файл, ОБЪЯСНЯЮЩИЙ дефект, содержит его имена и дефектом не является. */
+const strip = (src: string): string =>
+  src
+    .replace(/\/\*[\s\S]*?\*\//g, (m) => m.replace(/[^\n]/g, " "))
+    .replace(
+      /(^|[^:"'`])\/\/[^\n]*/g,
+      (m, head: string) => head + " ".repeat(m.length - head.length)
+    );
+
+const isScreen = (rel: string) =>
+  /(^|\/)src\//.test(rel) &&
+  !/(^|\/)(server|db|domain|application|bin)\//.test(rel) &&
+  /(^|\/)(client|ui)\//.test(rel);
+
+type Finding = { file: string; kind: string; what: string };
+const findings: Finding[] = [];
+
+/* ─── 1 и 2 · мёртвая проводка пропов ──────────────────────────────────────────────────── */
+
+for (const path of files) {
+  const rel = relative(ROOT, path).split("\\").join("/");
+  if (!isScreen(rel)) continue;
+  const src = strip(readFileSync(path, "utf8"));
+
+  // Тип пропов экрана: `export type <Имя>Props = { … }`.
+  const typeAt = src.match(/export type \w*Props\s*=\s*\{/);
+  if (!typeAt || typeAt.index === undefined) continue;
+  let depth = 0;
+  let end = typeAt.index;
+  for (let i = typeAt.index + typeAt[0].length - 1; i < src.length; i += 1) {
+    if (src[i] === "{") depth += 1;
+    else if (src[i] === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        end = i;
+        break;
+      }
+    }
+  }
+  const block = src.slice(typeAt.index, end);
+  const body = src.slice(end);
+
+  /*
+    Берутся ТОЛЬКО ключи верхнего уровня.
+
+    Первый прогон считал пропами всё подряд: имена полей вложенных объектов (`draft`, `patch`) и
+    параметры коллбэков (`onSave?: (patch: {…}) => …`). Одиннадцать «мёртвых пропов» из двенадцати
+    оказались ими. Признак, дающий столько ложных, отключают первым — и вместе с ним настоящую
+    находку.
+  */
+  const topLevel: { name: string; at: number }[] = [];
+  {
+    let d = 0;
+    let paren = 0;
+    for (let i = 0; i < block.length; i += 1) {
+      const c = block[i]!;
+      if (c === "{") d += 1;
+      else if (c === "}") d -= 1;
+      else if (c === "(") paren += 1;
+      else if (c === ")") paren -= 1;
+      else if (d === 1 && paren === 0 && /[A-Za-z_]/.test(c)) {
+        const rest = block.slice(i);
+        const key = rest.match(/^(\w+)\??\s*:/);
+        if (key) {
+          topLevel.push({ name: key[1]!, at: i });
+          i += key[0].length - 1;
+        } else {
+          // Не ключ — проматываем слово целиком, чтобы не разбирать его по буквам.
+          i += (rest.match(/^\w+/)?.[0].length ?? 1) - 1;
+        }
+      }
+    }
+  }
+
+  for (const m of topLevel) {
+    const name = m.name;
+    if (name.length < 3) continue;
+    // Считаем упоминания В ТЕЛЕ компонента, а не в типе.
+    const used = new RegExp(`\\b${name}\\b`).test(body);
+    if (used) continue;
+    const callback = /^on[A-Z]/.test(name);
+    findings.push({
+      file: rel,
+      kind: callback ? "мёртвый проп-коллбэк" : "мёртвый проп-значение",
+      what: name,
+    });
+  }
+}
+
+/* ─── 3 · дубль хваталки ───────────────────────────────────────────────────────────────── */
+
+/**
+ * Дубль считается только там, где узлы бывают на странице ОДНОВРЕМЕННО.
+ *
+ * Первый прогон дал 130 находок, и почти все были ложью: `f-name` есть и на создании круга, и на
+ * создании роли — экраны разные, вместе их не бывает. Настоящий дефект был другим:
+ * `id="q"` стоял в ОБОЛОЧКЕ и на экране поиска, а оболочка смонтирована всегда. Значит совпадать
+ * могут двое: оболочка с любым экраном и экран сам с собой (со своими же компонентами).
+ */
+const handlesOf = (path: string): Set<string> => {
+  const src = strip(readFileSync(path, "utf8"));
+  const out = new Set<string>();
+  // Порог был `{2,}`, и он пропускал ровно тот дефект, ради которого признак заведён: `id="q"`
+  // короче двух знаков. Односимвольная хваталка ничем не лучше длинной — она такая же чужая.
+  for (const m of src.matchAll(/(?:\bid|data-testid)\s*[=:]\s*"([\w-]+)"/g)) out.add(m[1] ?? "");
+  return out;
+};
+
+const shellFiles = files.filter((f) => /shell-tree|app-shell/.test(relative(ROOT, f)));
+const shellHandles = new Set<string>();
+for (const f of shellFiles) for (const h of handlesOf(f)) shellHandles.add(h);
+
+/** Экран — это КАТАЛОГ: сам файл плюс вынесенные из него компоненты рядом. */
+const screenDirs = new Map<string, string[]>();
+for (const path of files) {
+  const rel = relative(ROOT, path).split("\\").join("/");
+  if (!isScreen(rel) || shellFiles.includes(path)) continue;
+  const dir = rel.slice(0, rel.lastIndexOf("/"));
+  screenDirs.set(dir, [...(screenDirs.get(dir) ?? []), path]);
+}
+
+for (const [, paths] of screenDirs) {
+  const seenHere = new Map<string, number>();
+  for (const path of paths) {
+    for (const h of handlesOf(path)) seenHere.set(h, (seenHere.get(h) ?? 0) + 1);
+  }
+  for (const [h, n] of seenHere) {
+    if (shellHandles.has(h)) {
+      // Путь — КОНКРЕТНЫЙ файл, а не «каталог + оболочка»: очередь относит долг к слайсу по пути,
+      // и строка, которой нет на диске, до слайса не доедет.
+      findings.push({
+        file: relative(ROOT, paths[0]!),
+        kind: "дубль хваталки",
+        what: `${h} (с оболочкой)`,
+      });
+    } else if (n > 1) {
+      findings.push({ file: relative(ROOT, paths[0]!), kind: "дубль хваталки", what: h });
+    }
+  }
+}
+
+/* ─── 4 · читающий эндпоинт без вызывающего ────────────────────────────────────────────── */
+
+const routeFiles = files.filter((f) => f.endsWith("/server/routes.ts"));
+const clientText = files
+  .filter((f) => /(^|\/)(client|ui)\//.test(relative(ROOT, f)))
+  .map((f) => readFileSync(f, "utf8"))
+  .join("\n");
+
+for (const path of routeFiles) {
+  const rel = relative(ROOT, path).split("\\").join("/");
+  const src = strip(readFileSync(path, "utf8"));
+  /*
+    Адрес берётся из ПУТИ МОНТИРОВАНИЯ, а не из имени слайса.
+
+    Первый прогон объявил «без вызывающего» три слайса, у которых вызывающий есть: слайс
+    `transversal` монтируется на `/role-links`, `organization` — на `/organizations`,
+    `governance-history` — на `/governance-changes` и `/proposals`. Гейт, который ошибается на
+    четверти проверенного, перестают читать.
+  */
+  for (const mount of src.matchAll(/prefix:\s*"\/([\w-]+)"/g)) {
+    const prefix = mount[1] ?? "";
+    if (new RegExp(`/api/${prefix}\\b`).test(clientText)) continue;
+    // Есть ли у этого монтирования вообще чтение — иначе это чисто пишущий блок.
+    const after = src.slice(mount.index, mount.index + 4000);
+    if (!/\.get\(/.test(after)) continue;
+    findings.push({
+      file: rel,
+      kind: "читающий эндпоинт без вызывающего",
+      what: `GET /${prefix}`,
+    });
+  }
+}
+
+/* ─── отчёт и храповик ─────────────────────────────────────────────────────────────────── */
+
+const byKind = new Map<string, number>();
+for (const f of findings) byKind.set(f.kind, (byKind.get(f.kind) ?? 0) + 1);
+
+console.log(`\n=== ПРОВОДКА ЭКРАНА ===`);
+console.log(`Файлов просмотрено: ${files.length} · находок: ${findings.length}`);
+for (const [kind, n] of [...byKind.entries()].sort((a, b) => b[1] - a[1])) {
+  console.log(`  ${String(n).padStart(3)} · ${kind}`);
+}
+
+/** Ноль просмотренных файлов — не «чисто», а не отработавший гейт. */
+if (files.length === 0) {
+  console.error("\nОШИБКА: экранов не найдено — гейт не отработал.");
+  process.exit(1);
+}
+
+if (verbose) {
+  console.log("");
+  for (const f of findings) console.log(`  ${f.kind}: ${f.what}\n      ${f.file}`);
+}
+
+const byFile = new Map<string, number>();
+for (const f of findings) byFile.set(f.file, (byFile.get(f.file) ?? 0) + 1);
+
+if (write) {
+  const body = [
+    "# ПРОВОДКА ЭКРАНА — объявленный ДОЛГ, а не разрешение.",
+    "#",
+    "# Каждая строка: <файл> <число>. Форма та же, что у соседних гейтов, и не по симметрии:",
+    "# очередь слайсов относит долг к слайсу ПО ПУТИ, а значит путь обязан быть настоящим.",
+    "#",
+    "# Список СОКРАЩАЕТСЯ. Стало ноль — удаляй строку; долг дошёл до нуля целиком — снимай гейт.",
+    `# Записано ${byFile.size} файлов, ${findings.length} находок; просмотрено ${files.length}.`,
+    "",
+    ...[...byFile.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([f, n]) => `${f} ${n}`),
+    "",
+  ].join("\n");
+  Bun.write(ALLOW, body);
+  console.log(`\nбазовая линия записана: ${findings.length} в ${byFile.size} файлах\n`);
+  process.exit(0);
+}
+
+const declared = new Map<string, number>();
+if (existsSync(ALLOW)) {
+  for (const line of readFileSync(ALLOW, "utf8").split("\n")) {
+    const text = line.split("#")[0]!.trim();
+    if (!text) continue;
+    const at = text.lastIndexOf(" ");
+    declared.set(text.slice(0, at), Number(text.slice(at + 1)));
+  }
+}
+
+const fresh: string[] = [];
+const grown: string[] = [];
+const stale: string[] = [];
+for (const [file, n] of byFile) {
+  const was = declared.get(file);
+  if (was === undefined) fresh.push(file);
+  else if (n > was) grown.push(`${file}: было ${was}, стало ${n}`);
+}
+for (const [file, was] of declared) {
+  const now = byFile.get(file) ?? 0;
+  if (now === 0) stale.push(`${file} (было ${was}, стало 0)`);
+  else if (now < was) stale.push(`${file}: было ${was}, стало ${now} — поправь число`);
+}
+
+if (fresh.length) {
+  console.error(`\nНОВЫЙ ОБРЫВ ПРОВОДКИ:\n`);
+  for (const f of findings.filter((x) => fresh.includes(x.file)).slice(0, 40)) {
+    console.error(`  ${f.file}\n      ${f.kind}: ${f.what}`);
+  }
+}
+if (grown.length) {
+  console.error(`\nДОЛГ ВЫРОС:\n`);
+  for (const g of grown) console.error(`  ${g}`);
+}
+if (stale.length) {
+  console.error(`\nЗАПИСЬ ДОЛГА УСТАРЕЛА — поправь ${relative(ROOT, ALLOW)}:\n`);
+  for (const s of stale) console.error(`  ${s}`);
+}
+if (fresh.length || grown.length || stale.length) {
+  console.error(
+    `\nПроверка провалена: новых ${fresh.length}, выросших ${grown.length}, устаревших ${stale.length}.`
+  );
+  process.exit(1);
+}
+
+console.log(`Новых обрывов нет. Объявленный долг: ${findings.length}.\n`);