rust-anything
автор: erKam Yaman
English · Türkçe · 简体中文 · 繁體中文 · Deutsch · Français · Русский · Українська · 日本語 · 한국어 · Azərbaycanca · Oʻzbekcha · Қазақша · Кыргызча · Türkmençe · Татарча · ئۇيغۇرچە · Português
Этот перевод поддерживается сообществом и может отставать от английского README.
Перепишите всё приложение на Rust. Сохраняя его работоспособность на каждом шаге.
CLI, серверы и библиотеки — модуль за модулем, с проверкой соответствия оригиналу на каждом этапе.
Node.js и TypeScript · Python · C · Go · Ruby · Java · PHP и C# в превью
до 20x быстрее · воспроизведено 38 251 записанный кейс · 0 расхождений · одна команда
**Перепишите всё приложение на Rust — модуль за модулем.** rust-anything записывает поведение вашего текущего приложения на Node.js (TypeScript/JavaScript), Python, C, Go, Ruby или Java, а затем сверяет каждую переписанную на Rust часть с этой записью, прежде чем двигаться дальше — пока всё приложение не станет чистым Rust. Поддерживаются CLI, HTTP-серверы и библиотеки; код на Rust пишет ваш агент разработки (или вы сами). Инструмент способен отловить только то, что покрыто записью — подробнее см. в разделе [Что он не может отловить](#что-он-не-может-отловить). Нужно ускорить только медленную часть? Переносите именно её — по одному горячему пути за раз:
| Реальная нагрузка, результаты идентичны оригиналу | Оригинал | С rust-anything |
| --- | ---: | ---: |
| Поиск в боковой панели x18n, 50 000 ключей (TypeScript, Node) | 10 мс на запрос | **0,5 мс: в 20x быстрее** |
| Тот же поиск в браузере (wasm, один поток) | 10 мс | **0,95 мс: в 11,5x быстрее** |
| `slugify` на 20 000 строк (Python) | 98 мс | **в 17x быстрее** |
| `Shellwords.shellescape` из стандартной библиотеки Ruby, 50 000 значений | 88 мс | **в 11,8x быстрее** |
| `Slugify` на 50 000 строк (Go) | 49 мс | **в 4x быстрее** |
| `slugify` на 50 000 строк (Java) | 43 мс | **в 3x быстрее** |
Замеры выполнены на 4 ядрах; для каждого числа в [`demo/`](../demo) есть бенчмарк, который сначала проверяет полную идентичность результатов. Вызывать Rust по одному разу на каждую мелкую функцию обычно *медленнее*, чем JIT; rust-anything находит цикл, который действительно стоит перенести, и переносит его целиком.
> rust-anything — независимый проект, не связанный с Rust Project или Rust Foundation и не одобренный ими. «Rust» является товарным знаком Rust Foundation.
## Быстрый старт
Вставьте это в Claude Code, Codex, Cursor или Gemini CLI, и пусть ваш агент всё установит:
```text
Установи rust-anything: выполни `cargo install rust-anything`, затем `rust-anything setup`.
Скажи мне, когда тебя нужно будет перезапустить.
```
Или установите сами:
```sh
cargo install rust-anything # из crates.io
rust-anything setup # регистрирует инструмент в Claude Code, Codex, Cursor и Gemini CLI
```
Ещё не установлен тулчейн Rust? Готовые бинарные файлы для macOS, Linux и Windows прикреплены к каждому [релизу на GitHub](https://github.com/erkamyaman/rust-anything/releases), а для JavaScript-проектов тот же бинарник устанавливается командой `npm install -g rust-anything`.
В Claude Code инструмент также можно установить как плагин (MCP-сервер и навык; указанный выше CLI должен быть в `PATH`):
```text
/plugin install rust-anything --marketplace erkamyaman/rust-anything
```
`setup` добавляет MCP-сервер во все найденные агенты и устанавливает навык рабочего процесса туда, откуда агент читает навыки. Существующие настройки сохраняются, повторный запуск безопасен, а флаг `--remove` удаляет добавленные или обновлённые записи (не восстанавливая прежние значения, если `setup` их обновил). После этого можно давать агенту задачи, например:
- *«Перепиши этот CLI на Rust с помощью rust-anything от начала до конца и докажи, что он ведёт себя так же.»*
- *«Этот поиск ощущается медленным. Профилируй его через rust-anything и перенеси горячий цикл в Rust.»*
- *«Спланируй миграцию `src/parser/` на Rust с rust-anything; перенеси первый модуль и проверь его.»*
- *«Сравни производительность Rust-порта в `rust/text-rs` с оригиналом и скажи, стоит ли его выкатывать.»*
### Поддерживаемые агенты
| Агент | Что добавляет `rust-anything setup` |
| --- | --- |
| Claude Code | MCP-сервер в `~/.claude.json`, навык в `~/.claude/skills/` |
| Codex | MCP-сервер в `~/.codex/config.toml`, навык в `~/.codex/skills/` |
| Cursor | MCP-сервер в `~/.cursor/mcp.json` |
| Gemini CLI | MCP-сервер в `~/.gemini/settings.json` |
| Любой другой MCP-клиент | добавьте `rust-anything mcp` как stdio-сервер вручную (см. [Установка](#установка)) |
Перед изменением существующего файла `setup` сохраняет резервную копию рядом с ним (`.rust-anything.bak`).
Либо выполняйте шаги вручную:
```sh
rust-anything profile . -- node bench.mjs # что тормозит и кто это вызывает
rust-anything bridge . src/fuzzy.ts --batch fuzzyScore:text
# напишите src/port.rs (или поручите агенту), затем:
rust-anything record rust/fuzzy-rs && rust-anything build rust/fuzzy-rs
rust-anything diff rust/fuzzy-rs # каждый записанный кейс должен совпасть
rust-anything bench rust/fuzzy-rs # стало быстрее? вердикт покажет
rust-anything gate rust/fuzzy-rs # задача выполнена, только когда пройдена эта проверка
```
rust-anything не переводит код автоматически: код на Rust пишете вы или ваш агент (Claude Code, Codex, Cursor и др.). Инструмент даёт то, что агент не может надёжно угадать: куда уходит время, что переносить первым и в каком порядке, мост, чтобы остальной код вызывал Rust с неизменным API, точное эталонное поведение, которому порт обязан соответствовать, безопасный способ доставки и итоговую проверку (gate), фиксирующую готовность порта.
## Поддерживаемые языки
| Язык | Единица переноса | Мост | Чем записывается и воспроизводится |
| --- | --- | --- | --- |
| TypeScript/JavaScript | каталог или файл | napi-rs или wasm-bindgen со сгенерированным бинарным протоколом; включая классы и async | Node, напрямую выполняющий исходники `.ts` |
| Python | пакет или модуль | PyO3 (abi3), прямое преобразование, типизированные исключения | Python, импортирующий оригинал |
| C | файл `.c` | функции `extern "C"` с исходными именами и заголовочный файл | оригинал, скомпилированный в разделяемую библиотеку, вызов через ctypes, отдельный fork на кейс |
| Go | пакет | типизированные вызовы cgo и сгенерированный бинарный протокол в пакете с исходным API | сгенерированный Go-драйвер, собранный как отдельный модуль |
| Ruby | файл или каталог с функциями модуля | расширение magnus в исходных модулях | сгенерированный Ruby-драйвер |
| Java | пакет со статическими методами (`public static`) | типизированный JNI и сгенерированный бинарный протокол в классах-обёртках с исходными методами | сгенерированный драйвер на рефлексии |
| PHP (превью) | каталог функций и методов `public static` | далее: PHP FFI поверх C ABI | целые приложения уже сейчас: `app record`, `app replay` и входная точка (front door) для CLI и серверов (`php -S`) |
| C# (превью) | каталог методов `public static` | далее: P/Invoke поверх C ABI | целые приложения уже сейчас: `app record`, `app replay` и входная точка для CLI и серверов ASP.NET (`dotnet .dll`) |
Для каждого языка, кроме C, также генерируются пакетные классы (`--batch`): элементы пересекают границу один раз и остаются в Rust, а каждый вызов обрабатывает их все на всех ядрах.
Язык определяется по репозиторию (`go.mod`, `pom.xml`, `.csproj` или `.sln`, `pyproject.toml`, `Gemfile`, `composer.json`, `package.json`, иначе по преобладающим исходным файлам); флаг `--lang` переопределяет автоопределение. Типы берутся из исходного кода: типы TS, аннотации типов Python, сигнатуры C, Go, Java и C#, теги YARD в Ruby, типы и phpdoc в PHP; нетипизированные параметры, используемые как числа, выводятся как числовые.
PHP находится в превью: `analyze` планирует PHP-приложение (пакеты Composer и автозагрузка PSR-4, риски вроде нестрогого сравнения и переполнения целых чисел во float, сопоставление пакетов Composer с крейтами), а PHP CLI или сервер можно записать, воспроизвести и поставить за входную точку на Rust. Перенос отдельных модулей в Rust через PHP FFI — следующий этап ([issue #2](https://github.com/erkamyaman/rust-anything/issues/2)).
C# находится в превью аналогичным образом: `analyze` читает проекты `.csproj` и их пакеты NuGet (сопоставляемые с крейтами), разрешает директивы `using` в каталоги и отмечает особенности C# (`decimal`, `dynamic`, отложенные запросы LINQ, `Task`, `lock`, рефлексия). C# CLI или сервер ASP.NET можно записать, воспроизвести и поставить за входную точку на Rust; перенос отдельных модулей через P/Invoke появится далее.
## Как это работает
```
profile ──> analyze ──> bridge ──> record ──> port.rs ──> diff ──> bench ──> shadow ──> gate
где тра- что пере- Rust-крейт что делает пишете вы каждый быстрее? оба вари- готово,
тится носить и обёртка оригинал или агент кейс из вердикт анта рядом когда эта
время первым записи в проде проверка
пройдена
```
Оригинал остаётся источником истины: `record` прогоняет его на граничных случаях (и ваших входных данных) и сохраняет возвращаемые значения или исключения; `diff` воспроизводит каждый кейс на Rust; ничего не выкатывается в продакшн, пока всё не совпадёт и не пройдёт `gate`. Для вызывающего кода исходный API остаётся неизменным на протяжении всего пути.
Целое приложение проходит тот же цикл модуль за модулем внутри обвязки, которая доказывает корректность всей программы ([Портирование целого приложения](#портирование-целого-приложения)):
```
analyze --whole-app ──> app record ──> app front-door ──> на каждый модуль: цикл выше, затем app wire ──> app lift
структура, все что делает Rust владеет gate пройден, значит модуль отвечает чистый Rust,
зависимости, приложение точкой входа; на Rust: replay 100%, доля fallback доказанный
решения к принятию снаружи оригинал страхует снижается воспроизведением
```
## Цикл работы
| Шаг | Команда | Что делает |
| --- | --- | --- |
| 0. Профилирование | `rust-anything profile -- node bench.mjs` | Запускает реальную нагрузку под профилировщиком языка (node, cProfile, `go test` pprof, JFR, трассировщик Ruby): горячие функции по инклюзивному времени, их вызывающие стороны и циклы для пакетирования; помечает уже скомпилированный код (numba, Cython, JAX), где Rust даст мало выигрыша |
| 1. План | `rust-anything analyze ` | Модули (units), порядок переноса, риски с `file:line`, тип моста на модуль, подбор крейтов под зависимости, лучшие кандидаты для старта; `--whole-app` добавляет точки входа и общую структуру, каждую зависимость (импортированную или объявленную) с её крейтом, связные фрагменты (взаимно импортируемые модули переносятся вместе) и пронумерованные решения с рекомендованным выбором |
| 2. Мост | `rust-anything bridge ` | Крейт с привязками (`lib.rs`, плюс обёртка, которую загружает исходный язык) и заглушками для переноса (`port.rs`); `--batch fn:param` добавляет класс, удерживающий множество значений `param` внутри Rust |
| 3. Запись | `rust-anything record ` | Запускает оригинал на сгенерированных граничных кейсах (не-ASCII, эмодзи, `-0`, `NaN`, целые числа там, где ожидаются дробные и т. д.) и на всех семантических ловушках в каждом параметре (длина и регистр строк, знаковое деление, границы переполнения, печать float, порядок в map и при сортировке) и сохраняет `cases.jsonl`; `--float-tolerance 1e-9` разрешает расхождение float в пределах этой доли для числового кода |
| 3. Сборка | `rust-anything build ` | Собирает Rust-часть: `.node`, wasm-пакет, расширение Python или разделяемую библиотеку |
| 3. Сравнение | `rust-anything diff ` | Воспроизводит записанные кейсы на Rust тем же способом, которым к ним обращается исходный код; выводит список расхождений |
| 3. Бенчмарк | `rust-anything bench ` | Замеряет время выполнения записанных кейсов на оригинале и на Rust, включая накладные расходы моста |
| 4. Теневой режим | `rust-anything shadow ` | Подменяемый модуль, запускающий обе реализации, возвращающий результат оригинала и сообщающий о расхождениях; `RUST_ANYTHING_MODE=old\|shadow\|new` |
| 5. Gate | `rust-anything gate ` | fmt, clippy `-D warnings`, тесты, аудит `unsafe`, отсутствие неперенесённых заглушек, записанный падающий кейс для каждой ветки ошибки оригинала, запрет `unwrap`/`expect`/`panic!` там, где оригинал возвращает ошибку (если не помечено `// INFALLIBLE: <почему>`), сборка, API, поведение |
| Агенты | `rust-anything setup` | Регистрирует MCP-сервер (`rust-anything mcp`, каждый шаг как инструмент) и навык рабочего процесса ([`skills/rust-anything/SKILL.md`](../skills/rust-anything/SKILL.md)) в ваших агентах разработки |
## Портирование целого приложения
Цель — получить чистое Rust-приложение, которое ведёт себя точно так же, как оригинал, сохраняя оригинал в качестве эталона. Код на Rust пишет ваш агент; rust-anything задаёт порядок работ, генерирует каркас и проверяет каждый шаг. [Навык портирования целого приложения](../skills/rust-anything/whole-app.md) ведёт агента через весь процесс, начиная с решений, которые можете принять только вы:
- **Интервью (Grilling)**: агент задаёт вопросы раундами — к каждому прилагается рекомендованный вариант — пока не будут закрыты все решения, от которых зависит порт, записывает каждое как ADR в `rust/DECISIONS.md` и ведёт глоссарий `rust/GLOSSARY.md`, сопоставляющий термины оригинала с именами в Rust.
- **Исследование (Research)**: фоновые агенты изучают первоисточники каждой зависимости и записывают `rust/research/.md` со всеми найденными семантическими ловушками.
- **Между сессиями**: `rust/MAP.md` содержит список всех модулей и их статусы; сессия резервирует один модуль перед началом работы, а каждая контрольная точка оставляет `rust/HANDOFF.md` для следующей сессии. Модули одной волны могут переноситься параллельно субагентами.
- **Переключение (Cutover)**: агент делает всё, что может, и пишет `rust/cutover.sh` — интерактивный скрипт для шагов, которые можете выполнить только вы (деплой, DNS, секреты), с возможностью отката на каждом шаге.
Практики интервью, исследования и ведения сессий адаптированы из [навыков Мэтта Покока](https://github.com/mattpocock/skills).
Сначала план: `rust-anything analyze . --whole-app` добавляет структуру приложения (CLI, сервер или библиотека) и точки входа, каждую внешнюю зависимость (импортированную или объявленную) с её крейтом Rust и оценкой совместимости, порядок переноса в виде связных фрагментов (взаимно импортируемые модули переносятся вместе) и пронумерованные решения с рекомендованным ответом: оставляемые модули, заблокированные модули, зависимости без крейта или с частичной заменой.
Затем докажите поведение всей программы снаружи. `record` и `diff` проверяют один модуль; `app record` и `app replay` проверяют всё приложение целиком — для CLI и серверов на любом из шести языков (приложение выступает как чёрный ящик):
```sh
rust-anything app record . -- python3 cli.py # команда, запускающая оригинал
rust-anything app replay . # оригинал обязан пройти на 100%
rust-anything app replay . --build "target/release/mytool"
```
- `app record` запускает оригинал на собственных документированных примерах приложения (строки `$ mytool ...` в его Markdown- и shell-файлах вместе с указанными в них файлами), файле JSONL через `--inputs` (`{"name", "args", "stdin", "env", "files"}`) и семантических ловушках, выведенных из этих кейсов (не-ASCII и эмодзи-строки, деление и остаток для отрицательных чисел, переполнение, очень большие и очень маленькие float, порядок ключей map, отсутствующие файлы). Каждый кейс запускается дважды; всё, что отличается между двумя запусками, превращается в маску `[..]`. `--normalize timestamps|uuids|key-order` или `--normalize name=regex` добавляет нормализаторы, сохраняемые вместе с кейсами.
- Кейсы представляют собой файлы [trycmd](https://docs.rs/trycmd) в каталоге `rust/app-cases/`: `.toml` (argv, env, код возврата), `.stdin`, `.stdout`, `.stderr`, `.in/` (входные файлы) и `.out/` (созданные файлы). Их можно читать и править вручную; как только у порта появится бинарник, тест на Rust сможет прогонять их через `trycmd`.
- `app replay` запускает любую сборку на этих кейсах, выводит `passed/total`, пишет `rust/app-cases/replay-report.md` с diff для каждого упавшего кейса и завершается с ненулевым кодом при любом расхождении. Сборка, которая дописывает в файл, указанный в `RUST_ANYTHING_FALLBACK_LOG` (по одной строке на каждый откат к оригиналу), как это делает описанная ниже входная точка (front door), также получает в отчёте долю откатов (fallback rate).
- `app replay --case ` перезапускает один конкретный кейс по имени из отчёта: быстрый повторяемый цикл для исправления расхождения перед полным прогоном.
Затем перенесите точку входа в Rust и передавайте ей команды по одному модулю за раз:
```sh
rust-anything app front-door . # rust/app: каждая команда запускает оригинал
rust-anything app wire . textkit --command upper # после того как textkit-rs пройдёт gate
# напишите связующий код в rust/app/src/units/textkit.rs, затем:
rust-anything app wire . textkit # снова 100%, доля fallback ниже
```
- `app front-door` создаёт каркас `rust/app` — Rust-бинарник с именем приложения: парсер на clap для команд и флагов из записанных кейсов, где каждая команда запускает оригинал с теми же argv, stdin и окружением и пробрасывает его вывод и код возврата. Каждый такой вызов подсчитывается, поэтому воспроизведение свежего front door даёт 100% прохождения при 100% fallback (команда сама собирает и прогоняет replay, чтобы это показать). Она никогда не перезаписывает уже существующий `rust/app`: с этого момента код полностью ваш.
- `app wire --command ` прогоняет `gate` на крейте модуля (`--skip-gate`, если проверка только что прошла), добавляет его в `rust/app` как библиотеку, единожды создаёт `src/units/.rs` для заполнения вами или агентом (разобрать аргументы, вызвать `::port`, вывести то же, что печатает оригинал), направляет туда команды, затем собирает и запускает replay. Переменная `RUST_ANYTHING_UNIT_=original` временно возвращает подключённый модуль к оригиналу вплоть до этапа lift.
Подключите имя самого приложения как команду (`--command mytool`) для вызовов без имени команды: без аргументов, с неизвестными командами, при ошибках использования.
Когда replay проходит с долей fallback 0, а каждый модуль прошёл gate, превратите проект в чистое Rust-приложение:
```sh
rust-anything app lift .
```
- `app lift` откажется выполняться, пока не выполнены оба условия, и перечислит всё, что мешает: кейсы, всё ещё уходящие в fallback, связующий код, оставшийся заглушкой, модули, не прошедшие gate.
- Сначала на копии она удаляет путь fallback и аварийные переключатели, превращает каждый крейт модуля в обычную библиотеку внутри `rust/app` (без `cdylib`, привязок и сгенерированных обёрток) и добавляет `rust/app/tests/app_cases.rs`, который гоняет `rust/app-cases` через trycmd по `cargo test` — так что для CI больше не нужно ничего, кроме cargo.
- Затем запускается чеклист lift: fmt, clippy `-D warnings` и тесты на каждом модуле и на `rust/app`, сборка или проверка каждой целевой платформы из `rust/DECISIONS.md` (где она установлена), проверка файлов, читаемых в рантайме, и невстроенных каталогов с ресурсами, а также replay на чистом бинарнике. Изменения записываются обратно только после прохождения всех пунктов. Оригинал никогда не изменяется.
### Серверы
Те же команды проверяют HTTP-серверы. `--http` указывает, что команда запускает сервер; порт передаётся через `PORT` или `{port}` в команде (`--port` — для сервера, всегда слушающего фиксированный порт):
```sh
rust-anything app record . --http -- node server.js
rust-anything app replay .
rust-anything app front-door . # axum: все маршруты проксируются
rust-anything app wire . api --route 'GET /users/{id}' --route '*'
rust-anything app lift .
```
- Запросы берутся из строк `curl` в документации приложения (`curl -X POST -d ... http://localhost:8080/x`), из `--inputs` (`{"name", "method", "path", "headers", "body"}`) и из ловушек: сегменты пути и параметры query заменяются на те же ловушки, что и аргументы CLI, тела запросов — на текстовые и JSON-ловушки, плюс запрос на несуществующий маршрут. При каждом прогоне сервер стартует с чистого листа и получает запросы по порядку имён, так что состояние между запросами сохраняется.
- Кейсы сохраняются в `rust/app-cases/http/.toml` (запрос, статус и значимые заголовки) и `.body` (тело ответа, с `[..]` в местах, где два запуска разошлись). Заголовки `Date`, `Server` и прочие заголовки уровня конкретного ответа исключаются; любую ненужную строку заголовка можно удалить.
- Входная точка представляет собой сервер на axum, который запускает оригинал на отдельном порту и проксирует каждый маршрут, на который не отвечает ни один модуль. `wire --route` принимает маршруты axum: `METHOD /path/{param}`, `/path` для любого метода, `*` для всего остального; связующий код получает маршрут, его параметры и запрос. `lift` удаляет прокси; после этого HTTP-кейсы выполняются в CI через `app replay`.
### Библиотеки
У библиотеки нет отдельного процесса для воспроизведения: её публичный API сам служит входной точкой, а доказательством выступают записанные кейсы каждого модуля.
```sh
rust-anything app front-door . # rust/app: Rust-крейт с публичным API
# каждый модуль проходит цикл: bridge, record, port.rs, build, diff, gate; затем:
rust-anything app wire . textkit-rs # реэкспортируется из rust/app; оригинал импортирует его shadow-модуль
rust-anything app replay . # кейсы каждого подключённого модуля; fallback = экспорты, всё ещё в оригинале
rust-anything app lift .
```
- `app front-door` находит публичный API (экспорты каждого модуля), если в репозитории нет `main` и нет сервера (иначе укажите `--library`), и создаёт каркас библиотечного крейта `rust/app`. Каждый подключённый модуль становится его подмодулем: `pub use textkit_rs::port as textkit;`.
- `app wire` принимает крейт, созданный командой `bridge`, прогоняет `gate` и генерирует теневую замену (shadow drop-in) для модуля: исходный пакет импортирует её вместо оригинального модуля, так что вызывающий код сохраняет прежний API и попадает в Rust. `RUST_ANYTHING_UNIT_=original` переключает модуль обратно (для C — соберите без флагов shadow-модуля).
- `app replay` прогоняет записанные кейсы каждого подключённого модуля через его привязки. Доля fallback показывает процент публичных экспортов, за которые Rust ещё не отвечает: неподключённые модули и экспорты, оставленные командой `bridge` на исходном языке.
- `app lift` требует нулевой fallback и прохождение `gate` всеми модулями; она убирает привязки, обёртки и shadow-прослойки из модулей и оставляет `rust/app` одной чистой Rust-библиотекой. Она не трогает ни один `port.rs`, поэтому кейсы, совпадавшие через привязки, по-прежнему описывают его поведение; чеклист предупредит о файлах оригинала, которые всё ещё импортируют shadow-модули.
Все пять команд доступны и как инструменты MCP: `app_record`, `app_replay`, `app_front_door`, `app_wire` и `app_lift`.
## Разбор кейса: ядро x18n
Все 29 функций ядра x18n, которые можно перенести без изменения API, были портированы с помощью rust-anything: каждый gate пройден, и 7 925 записанных кейсов совпадают в точности. Затем `rust-anything bench` показала, что при вызове из JS порты работают медленнее исходного TS, поскольку накладные расходы моста превышают саму работу функций. Полный отчёт: [`demo/x18n-core`](../demo/x18n-core/README.md). Этот урок встроен в сам процесс: измеряйте производительность через `bench` до того, как выкатывать порт.
## Горячие пути: держите данные в Rust
Порт, вызываемый по одному разу на каждый элемент, платит цену моста на каждом элементе и проигрывает JIT. Выигрыш даёт перенос самого цикла: `profile` находит его, а `--batch` генерирует класс, который принимает элементы один раз и прогоняет функцию по всем сразу за один вызов, на всех ядрах, возвращая результаты в типизированном массиве.
```sh
rust-anything profile ../x18n -- node --experimental-strip-types $PWD/demo/x18n-search/search.ts .
# -> fuzzyScore: четверть всего прогона, вызывается на каждый ключ из `matched`: нужно пакетировать
rust-anything bridge ../x18n packages/core/src/fuzzy.ts --batch fuzzyScore:text
```
```js
const search = new FuzzyScoreBatch(keys) // один раз
const order = search.rank(query, 0) // на каждое нажатие клавиши: индексы, лучшие в начале
```
Структура `FuzzyScoreIndex` в `port.rs` заменяет цикл по умолчанию алгоритмом, который один раз подготавливает элементы и умеет ранжировать самостоятельно (`rank`): она хранит ключи в нижнем регистре с битовой маской символов для каждого, таблицу первых позиций каждого частого символа по ключам (однобуквенный запрос — одна колонка) и совпадения прошлого запроса (ввод `se` после `s` переоценивает только то, что совпало с `s`). В поиске по боковой панели x18n на 50 000 ключей, при посимвольном вводе, с идентичными результатами:
| Вариант | На запрос | к TS |
| --- | ---: | ---: |
| TS: `map(fuzzyScore)`, фильтрация, сортировка | 10 мс | 1x |
| TS с тем же сужением выборки, что и в индексе | 4,1–5,4 мс | 2x |
| Тот же порт с поштучным вызовом на ключ | - | 0,2–0,4x |
| `FuzzyScoreBatch`, индекс по умолчанию (4 ядра) | 5,1 мс | 1,7x |
| `FuzzyScoreBatch` с `FuzzyScoreIndex` (napi, 4 ядра) | 0,45–0,56 мс | **18–22x** |
| То же самое с wasm (один поток) | 0,95 мс | **11,5x** |
Даже против TS с аналогичным сужением выборки Rust всё равно быстрее в 7–12 раз (wasm — в 5 раз). Преобразуйте возвращённые индексы обратно в ключи обычным циклом: `Array.from(order, i => keys[i])` обходился в 20 раз дороже — 0,4 мс.
Пакетные обёртки генерируются для каждого языка и обгоняют оригинал даже там, где поштучные вызовы проигрывают. Та же работа на 4 ядрах, идентичные результаты и ошибки (бенчмарки лежат в каждом каталоге demo):
| Язык | Нагрузка | Оригинал | Поштучный порт к оригиналу | Пакетный к оригиналу |
| --- | --- | ---: | ---: | ---: |
| TS | Поиск x18n, 50 000 ключей | 10 мс | 0,2–0,4x | **20x** |
| Python | `slugify`, 20 000 строк | 98 мс | - | **17x** |
| Ruby | `slugify`, 20 000 строк | 110 мс | - | **12,7x** |
| Ruby | `shellescape` (stdlib), 50 000 смешанных значений | 88 мс | - | **11,8x** |
| Go | `Slugify`, 50 000 строк | 49 мс | 0,93x | **4x** |
| Java | `slugify`, 50 000 строк | 43 мс | 0,68x | **3x** |
Компилируемые оригиналы выигрывают меньше: обработка одного элемента уже быстрая, поэтому пакетный режим побеждает за счёт числа ядер. Пакетные крейты используют аллокатор mimalloc: с системным аллокатором пакетная обработка для Go оказывалась медленнее одного потока. Демо: [`demo/x18n-search`](../demo/x18n-search/README.md).
## Реальный код на шести языках
Пакет `path` из Go, `shellwords` из Ruby, `colorsys` из Python, поведение JDK и glibc за небольшими фасадами: каждый порт проходит свой gate, всего 13 010 записанных кейсов. Прогоны выявили и помогли исправить ошибки в самом rust-anything (расхождение float на один ULP через `serde_json`, падения C во время записи, передача мусорных входов нетипизированному коду). При поштучном вызове функций порт на Ruby работает в 4,4 раза быстрее Ruby, а порт на Python — в 1,35 раза быстрее CPython, тогда как листовые функции Go и Java остаются быстрее на родном языке; в пакетном режиме выигрывают все (см. таблицу выше). Отчёт: [`docs/real-world-languages.md`](./real-world-languages.md).
## Пример: реальный модуль из x18n
`packages/core/src/fuzzy.ts` из [x18n](https://github.com/x18n-dev/x18n), перенесённый обоими способами в [`demo/`](../demo):
```sh
rust-anything analyze ../x18n # fuzzy.ts: готов, wasm-bindgen (ядро работает в браузерах)
rust-anything bridge ../x18n packages/core/src/fuzzy.ts --out demo/fuzzy-rs
rust-anything record demo/fuzzy-rs --count 2000
# напишите src/port.rs
rust-anything gate demo/fuzzy-rs
```
Первый порт, индексировавший строки по `char` из Rust, прошёл простые тесты, но провалил `diff`:
```
198/200 cases match
- fuzzyScore("b😀", "a😀b😀c"): expected {"ok":1997}, got {"ok":1998}
```
В JS `indexOf` считает кодовые единицы UTF-16, поэтому один эмодзи занимает две позиции. Порт в `demo/*/src/port.rs` использует сгенерированные вспомогательные функции `utf16` и проходит 2000/2000 кейсов и gate как в варианте napi-rs (`demo/fuzzy-napi`), так и в wasm-bindgen (`demo/fuzzy-rs`).
План, который rust-anything формирует для всего x18n: [`docs/examples/x18n.md`](./examples/x18n.md).
## Установка
```sh
cargo install --path .
```
`record`, `diff` и `bench` запускают оригинал в его собственной среде выполнения: Node 22.6+ для TS (выполняет исходники `.ts` напрямую), Python 3.9+ для Python и C (ctypes), Go 1.21+, Ruby 3+, JDK 17+ (`javac` и `java`). Для C также нужен компилятор C. Для wasm-мостов дополнительно требуются `rustup target add wasm32-unknown-unknown` и `cargo install wasm-bindgen-cli --version <версия wasm-bindgen крейта> --locked`; команда `build` подскажет точную версию.
Для агентов всё регистрирует команда `rust-anything setup` (см. Быстрый старт). Чтобы вместо этого добавить MCP-сервер вручную в один проект (`.mcp.json`):
```json
{ "mcpServers": { "rust-anything": { "command": "rust-anything", "args": ["mcp"] } } }
```
## Какие решения принимает `bridge`
- Экспорты, которые не могут пересечь мост, остаются на исходном языке с указанием причины, а shadow-модуль реэкспортирует оригинал. Для TS это: функции, принимающие или возвращающие функции, генераторы и итераторы, RegExp, проверки `instanceof`, дженерики, а также значения, чьи типы (прослеживаемые через импорты, реэкспорты и `extends`) содержат функции. `--keep "name: reason"` позволяет оставить больше, например код, зависящий от данных `Intl`.
- Типы TS сопоставляются с типами Rust, псевдонимы типов разрешаются через импорты, а типы параметров выводятся из значений по умолчанию; структурированные значения передаются по сгенерированному бинарному протоколу (JSON используется лишь как запасной вариант для структур, которые протокол не моделирует).
- JSON не умеет представлять `undefined`, NaN, Infinity, -0 и непарные суррогаты: структурированные значения несут маркеры (`{"$undefined": true}`, `{"$num": "NaN"}`, `{"$utf16": [...]}`), которые сгенерированный `index.cjs` преобразует с помощью утилит в файле `js.rs` крейта.
`record` запускает исходники TS как есть: резолвер-хук Node обрабатывает импорты в стиле бандлеров (`./errors` в `./errors.ts`), `--resolve-from` подставляет пакеты npm, если в репозитории они не установлены, а TS, требующий трансформации (enum, свойства параметров), автоматически перезапускается с `--experimental-transform-types`.
## Что анализирует `analyze`
- Пакеты (`package.json`) и исходные файлы; пропускает `node_modules`, артефакты сборки, фикстуры, песочницы и конфиги инструментов. В `