Yjs против Automerge на практике: совместное редактирование

Вторая статья серии закрыла механизм: сходимость — это три свойства операции слияния, порядок перенесён в сами данные, а цена — метаданные, tombstones и отказ от серверных инвариантов. Но как только вы решаете «делаю совместимый редактор», возникает вопрос, на который механизм не отвечает: какую именно библиотеку брать. Стандартный ответ — «посмотрю, у кого больше звёзд» или «возьму ту, что популярнее в стеке» — пропускает единственный вопрос, который реально решает выбор: какая форма данных у вас на самом деле.

Yjs и Automerge — обе CRDT, обе MIT, обе зрелые. Они не два формата одних и тех же данных и не «один лучше другого». Yjs оптимизирован под документ: текст, курсоры, присутствие, компактная дельта. Automerge оптимизирован под произвольное состояние с историей: JSON-подобный документ, ветвление, возможность пройти историю как в git. Разница между ними — не качество, а то, за что вы платите и что бесплатно.

Разбираем это на живом коде: как устроена дельта Yjs и что такое awareness (присутствие), как выглядит модель изменений Automerge и почему её «легко» превратить в event-log, и где проходит граница, за которой PHP-релей из «зеркала» снова становится «судьёй» — то есть вся конструкция перестаёт быть local-first.

Часть I. Выбор определяет форма данных, а не популярность

Начнём с того, что обычно идёт последним и потому портит решение.

В Части V второй статьи мы уже разложили обе библиотеки по таблице — версия, ядро, размер, форма данных. Там же стояло предупреждение: размер пакета в npm (≈2,3 МБ у Yjs против ≈47,5 МБ у Automerge на 18.11.2026) — не «Automerge хуже», а цена WASM-сборок под разные таргеты (браузер, Node, workerd) и более широкой модели истории. Если вы выбираете по звёздам или по размеру бандла, вы пропускаете единственный вопрос, который имеет значение.

Этот вопрос звучит так: что у вас — документ или состояние?

ДОКУМЕНТ (доменная форма «текст + вложенные структуры, который правят»)
  → единица смысла = символ/блок текста; порядок символов первичен;
    нужна совместная печать в реальном времени, курсоры, presence;
    история — приятная опция («откатить абзац»), а не модель данных.
  → Yjs построен ровно под это.

СОСТОЯНИЕ (доменная форма «JSON-объект, который evolves и whom ветвят»)
  → единица смысла = поле/коллекция; есть смысл у всего дерева сразу;
    нужна история как первоклассная сущность: diff, ветка, слияние веток;
    документ можно использовать как журнал событий (event log).
  → Automerge построен ровно под это.

Путаница стоит дорого в обе стороны. Взять Yjs для «состояния с ветвлением» — значит руками собирать то, что Automerge даёт моделью: Yjs не хранит историю как первоклассную структуру, у него есть снимки (Y.snapshot / Y.encodeSnapshot — возможность зафиксировать прошлое состояние, но не ветвить и не мержить прошлое). Взять Automerge для «живого текста на десять тысяч символов» — значит платить тяжестью состояния и WASM-мостом там, где Yjs отдаёт компактную дельту и оптимизированный rope-структурой текст.

Главный тезис статьи: это не два формата одних данных и не «один лучше». Yjs оптимизирован под форму «документ», Automerge — под форму «состояние с историей». Выбор = выбор модели данных, а не выбор библиотеки.

Отсюда практическое правило, которое экономит неделю рефакторинга: если в вашем продукте есть слово «ветка», «версия», «история изменений, которую видно пользователю», «журнал событий, который можно переиграть» — вы ближе к Automerge. Если есть слово «печатает», «курсор соседа», «совместная строка», «быстрый отзыв правки» — вы ближе к Yjs.

Теперь — как каждая из них устроена, чтобы понять, почему правило работает.

Часть II. Yjs: дельта, присутствие и цена свидетеля

Почему дельта получается компактной

Ключевая идея, на которой держится всё практическое преимущество Yjs в текста.

Во второй статье мы вывели: чтобы конкурентные вставки в одну позицию сошлись, каждый символ получает уникальный идентификатор при рождении, и порядок задаётся сравнением идентификаторов, а не индексом в массиве. Так и устроена Yjs-структура текста: это не строка, а связный список «спанов» (кусков), где у каждого спана есть (клиент, clock) — идентификатор позиции при рождении.

Из этого следует то, ради чего Yjs и берут: дельта — это не «что изменилось в строке» (diff), а «какие операции не видел получатель». Когда две реплики встречаются, они обмениваются не текстом и не diff двух текстов, а минимальным набором операций, которых нет у собеседника. Технически это два шага:

// Клиент знает состояние сервера (или другой реплики) как «вектор версий».
const stateVector = Y.encodeStateVector(remoteDoc);   // что удалённая реплика уже видела
// Отправляем ТОЛЬКО то, чего там нет.
const delta = Y.encodeStateAsUpdate(localDoc, stateVector);
// Принявший, у которого уже есть stateVector, применяет delta и догоняет.
Y.applyUpdate(remoteDoc, delta);

Для нового участника, который ничего не видел, stateVector пустой, и encodeStateAsUpdate(localDoc) отдаёт полное состояние. То есть один и тот же механизм покрывает и «догнать», и «полное состояние с нуля» — просто у пустого вектора дельта вырождается в полное состояние. Это очень удобная инвариантность протокола, и она же причина, почему y-protocols (готовая реализация sync-протокола, y-protocols/sync) работает с любым числом подключённых реплик без «режима загрузки» против «режима live».

Сравните с наивным «отправляем весь текст на каждое изменение»: на документе в 20 КБ и десяти правках в секунду вы бы гоняли сотни килобайт в секунду на каждого участника. Дельта гонит байты правки. Это не микрооптимизация — это то, что делает совместное редактирование вообще возможным по каналу.

Presence — не данные документа, и это важно не путать

В Yjs есть отдельная сущность — awareness (из y-protocols/awareness), поверх того же сокета, что несёт изменения. Awareness хранит летучее: где курсор каждого участника, кто печатает, цвет выделения. Принципиально: это не часть CRDT-документа.

import { Awareness } from 'y-protocols/awareness';

const awareness = new Awareness(localDoc, provider);
// Локально: куда я смотрю.
awareness.setLocalStateField('cursor', { index: 42 });
// Соседей читаем как события, а не как состояние документа:
awareness.on('change', (events) => {
  for (const e of events) {
    renderRemoteCursor(e.user, awareness.states.get(e.user));
  }
});
// Ушёл из сети / закрыл вкладку — awareness сам уберёт stale-состояния по TTL.

Почему это отдельная сущность, а не поле документа? Потому что курсор соседа через сутки не должен лежать в истории вашего файла и не должен участвовать в сходимости: он не данные, а состояние соединения. Если положить курсоры в CRDT — вы получите tombstones и рост метаданных (Часть IV второй статьи) на том, что вообще не должно сохраняться. Awareness спроектирован как «сбрасываемое и протухающее»: TTL вычищает ушедших, ничего в реплику не пишется.

Это различие пригодится в Части IV, когда мы допишем релей:presence-канал и данные-канал идут одним сокетом, но сервер обязан различать их по поведению (данные — хранить и пересылать, presence — только пересылать, никогда не хранить как истину).

Цена свидетеля

Вот где Yjs требует платёж, о котором в обзорах пишут туманно.

Yjs компактен именно потому, что не несёт в себе полной истории как модели данных: дельта вычисляется из текущего состояния и вектора версий. Но это значит, что чтобы вычислить «чего не хватает собеседнику», нужно знать состояние собеседника — а состояние собеседника знает тот, кто его хранит, то есть релей (или другая реплика, если она видна). В чисто P2P это работает, но как только появляется «спящий» участник, который вернётся через сутки, дельту для него должен кто-то посчитать — и это сервер, у которого есть «свидетельство» состояния остальных.

Это не дефект: это выбор модели. Он означает, что Yjs-релей имеет смысл делать сохраняющим (y-websocket в комплекте имеет persistence-плагин), иначе новый участник не сможет получить полное состояние, когда все active-клиенты отключатся. То есть «локальные данные + сервер-только-транспорт» в чистом виде для Yjs не работает без одной оговорки: сервер обязан что-то хранить, иначе дельта неоткуда. И вот здесь (Часть IV) важно удержать границу: хранить непрозрачные обновления ≠ знать правду о содержимом. Yjs-релей хранит и пересчитывает дельты, но не решает, какая правка «правильная».

Часть III. Automerge: изменения как объекты и история как git

Модель изменений

У Automerge первоклассная сущность — не документ и не символ, а изменение (change). Каждая правка, завёрнутая в Automerge.change,produce изменения: объект, который можно взять, переслать, применить к другой копии, сохранить в журнал.

import * as Automerge from '@automerge/automerge';

// Форма данных — обычное JS-объект/массив/текст; это и есть «состояние».
let doc = Automerge.from({ title: '', tags: [], body: '' });

// Правка = изменение. Возвращается НОВОЕ значение (иммутабельно).
doc = Automerge.change(doc, (d) => { d.title = 'Заметка' });

// Изменения можно извлечь как данные и переслать другому.
const changes = Automerge.getChanges(Automerge.emptyDoc(), doc); // всё, что было
// ... передать changes по сети ...
const [newDoc] = Automerge.applyChanges(remoteDoc, changes);      // применить у себя

Сразу видно отличие от Yjs: здесь нет «дельты из вектора» — есть явный список изменений, который вы можете достать, сериализовать, записать в таблицу как event log и проигрывать. Это не транспортная оптимизация, а модель данных: история — часть того, чем документ является.

Текст в Automerge — тоже первоклассный (строка внутри документа — collaborative-текст, правится через Automerge.splice), но лежит внутри общего дерева состояния, а не вынесен в отдельную «документ-центричную» структуру, как rope в Yjs.

История, ветвление, откат как built-in

Из «изменений как объектов» следуют вещи, которые в Yjs вы бы строили руками:

  • История. Automerge.getHistory(doc) — список изменений с метаданными; Automerge.changeAt(doc, {start: ops}) — править документ так, как он выглядел в точке истории, не создавая отдельной ветки (это есть в официальных доках: «Make a change to the document as it was at a particular point in history … equivalent history, but without having to create a fork»).
  • Ветки и слияние веток. Раз изменения — данные, историю можно развернуть на точку и пойти в другую сторону: настоящий git-модель, где ветвление и merge — часть модели, а не поверх обёртка.
  • Diff между состояниями. Раз есть история изменений, «чем отличается вчера от сегодня» вычисляется, а не прикладывается из снимков.

Именно поэтому Automerge часто берут не ради совместного редактирования, а как локальную базу с синхронизацией и историей: приложение пишет изменения в документ, документ — и есть журнал; синхронизация между устройствами — это getChanges/applyChanges, история — это та же таблица, которую можно переиграть. Для такого сценария «тяжесть» истории — не цена, а функция.

Где история становится платой

Та же модель, доведённая до текста, даёт обратный эффект.

Историю нельзя выбросить. Yjs-дельта компактна, потому что история не хранится как первоклассная сущность. Automerge по дизайну keep every change — это и есть его суперсила (diff, ветка, откат) и его потолок: документ, который правили год, несёт год изменений в себе. Для заметки на пять правок это ничего; для «ленты на миллион записей» или «текста, который рефакторили неделю по букве» — это раздутая реплика и медленный applyChanges при первом открытии (надо проиграть всю историю). Плюс WASM-ядро: на длинном тексте операции идут через Rust→WASM-мост, и это закладывает стоимость в latency на каждое нажатие.

Практический вывод: Automerge «проигрывает» на живом совместном тексте не потому, что хуже, а потому что платит за модель истории, которую там никто не просил. Yjs «проигрывает» на «состоянии с веткой», потому что историю приходится доделывать снимками, которых для ветвления мало.

Отдельная ловушка, общая для обеих и вытекающая из Части IV второй статьи: обе дают сходимость, но не дают инвариантов. «Один исполнитель на задачу», «баланс ≥ 0», «этап не раньше подэтапа» — ни Yjs, ни Automerge не удержат: это не свойство CRDT, а свойство приложения, и его вы проверяете своим слоем поверх. Выбирать библиотеку не по этому критерию — правильный выбор; но считать, что выбор библиотеку решает и его — ошибка.

Часть IV. PHP-релей: тонкий — и как не сорваться в судью

Пора собрать то, что первая и вторая статьи обещали, а третья обязана показать без иллюзий: как выглядит сервер, который остаётся зеркалом.

Важная оговорка о глубине. Ниже — рабочий скелет тонкого релея, не production-библиотека и не готовый Ratchet-проект: он показывает правильную форму (соединение → таблица непрозрачных обновлений → пересылка) и три места, где обычно срываются. Полноценный сокет-сервер на PHP (Ratchet/ReactPHP), авторизация по документу, горизонтальное масштабирование и persistence — это та же инфраструктура, что разобрана для публичных сокетов в «Защите API» и в «Потоках SSE/WebSocket»; сюда переносится один-в-один.

Скелет: таблица обновлений, не «эталон»

PHP-сторона, утрированно. Релей не парсит тело сообщения как документ — для него это непрозрачные байты обновления Yjs/Automerge.

PHP
<?php
// Обезличенный skeleton. example.test / sync.example.test.
// Это НЕ рабочая Ratchet-библиотека — это форма, у которой надо
// дописать транспорт (WebSocket-loop), авторизацию и storage.

final class SyncRelay {
    /** @var array<string, array<int, string>> docId => список непрозрачных updates (по порядку записи) */
    private array $log = [];
    /** @var array<string, array<int, object>> docId => подключённые сокеты */
    private array $rooms = [];

    /**
     * Пришло update от участника.
     * КЛЮЧЕВОЕ: мы НЕ применяем его к «эталону». Мы НЕ решаем, какое
     * состояние верное. Мы кладём байты в журнал и рассылаем остальным.
     */
    public function onMessage(string $docId, object $conn, string $bytes): void {
        if (!$this->canWrite($docId, $conn)) {        // граница 1: права — до записи
            $conn->close('forbidden');
            return;
        }
        if (strlen($bytes) > self::MAX_UPDATE) {      // граница 2: размер кадра
            return;                                   // иначе клиент зальёт RAM «валидным» гигантом
        }

        // update Yjs/Automerge непрозрачен: кладём как есть.
        $this->log[$docId][] = $bytes;

        // рассылка всем в комнате, кроме автора (автор уже применил локально).
        foreach ($this->rooms[$docId] as $peer) {
            if ($peer !== $conn) {
                $peer->send($bytes);
            }
        }
    }

    /**
     * Новый участник. Граница 3: мы отдаём ему ЖУРНАЛ обновлений, а не
     * «готовый документ». Клиент сам применит их к своему (пустому) doc
     * и сойдётся — потому что сходимость это обязанность типа, не сервера.
     */
    public function onJoin(string $docId, object $conn): void {
        $this->rooms[$docId][] = $conn;
        foreach ($this->log[$docId] as $bytes) {       // пересылаем update-ы, не результат
            $conn->send($bytes);
        }
        //presence (awareness) тут НЕ ретранслируем как историю: он летучий.
    }

    private function canWrite(string $docId, object $conn): bool { /* авторизация по документу */ return true; }
    const MAX_UPDATE = 1_000_000;
}

Заметьте, чего тут нет: нет merge на сервере, нет «применили патч к эталону и послали результат», нет «сравнили timestamp и отбросили устаревшее». Всё это — соблазн любого, кто писал CRUD, — и всё это превращает релей в server-as-truth (см. ниже). Для Yjs есть оптимизация: вместо пересылки всего лога новому участнику отдать ему encodeStateAsUpdate дельту (это и есть «серверный witness» из Части II — сервер хранит, чтобы посчитать дельту, но не решает правду). Форма остаётся той же: передача состояния, а не вердикта.

Три границы, за которыми local-first умирает

Граница 1 — права. Релей обязан аутентифицировать на уровне документа (кто может писать в docId), иначе любой гость зальёт обновления в чужой документ — формат-то валидный. Это не «CRDT-задача», это задача транспорта: см. «Защиту API» про Origin-проверку, лимит частоты и потолок соединений на пользователя — переносится сюда без изменений.

Граница 2 — ресурсы. «Непрозрачные байты» не означают «сколько влезет». Ограничение размера одного update, частоты сообщений и числа комнат — единственная защита от того, что корректный по формату, но гигантский пакет положит сервер. Это та же дисциплина, что для любого публичного сокета.

Граница 3 — перестать быть судьёй. Самая коварная, потому что сорваться в неё выглядит как «оптимизация». Как только релей начинает:

  • применять патч к «эталону» и рассылать результат, а не исходное обновление,
  • отбрасывать обновления «как устаревшие» по своему времени,
  • пересобирать состояние в «свой формат»,

— он становится server-as-truth с кэшем на клиенте. Клиент, чьё изменение не вошло в эталон, тихо теряет правку (LWW с красивой обёрткой, грабля №5 первой статьи и №12 второй). И это происходит ровно тогда, когда кто-то решит «сэкономить трафик, отдавая готовый документ, а не журнал». Экономия настоящая; потеря данных тоже настоящая.

Чек-лист релея: сервер хранит непрозрачные обновления; отдаёт историю обновлений (или дельту из неё) новому, но не вердикт; проверяет права до записи; ограничивает размер и частоту. Если хоть один пункт нарушен — это уже не local-first, а старое CRUD с лишним слоем, и расплата придёт молча, правкой, которая пропала.

Одно честное слово про масштаб

PHP-релей с логом обновлений не бесконечен: без компакции (та самая сборка мусора из Части IV второй статьи) лог растёт, а новый участник при каждом открытии качает всю историю. Для документа на десять человек и правки раз в неделю — запаса на годы. Для «тысячи правок в час на живой доске» нужна компакция и, скорее всего, не PHP-релей посередине, а специализированное хранилище с порогами стабильности. Честно признать потолок ретя — часть дизайна, а не его слабость.

Часть V. Таблица выбора и сценарии, где каждый проигрывает

Соберём практический итог, который и был целью статьи.

Ваш вопросБерётеПочему
Совместный текст в реальном времени, курсоры, «печатает ещё…»Yjsrope-текст + компактная дельта + готовый awareness/sync-протокол
Состояние приложения с ветвлением, историей, diff-версийAutomergeизменения как первоклассные данные; git-подобная история из коробки
Нужен журнал событий, который можно переиграть / офлайн-«что было на прошлой неделе»AutomergegetChanges/applyChanges + changeAt покрывают это моделью
Нужна компактная синхронизация между вкладки/устройства, история не нужнаYjsдельта из stateVector гонит байты правки, а не всю историю
И то, и другое в одном продуктеГибрид по островкамсовместный редактор — Yjs; настройки/проект с версиями — Automerge; local-first вообще бывает островами (первая статья)

И — чего не решает ни одна из них, чтобы это не всплыло сюрпризом:

  • Инварианты. «Один исполнитель», «баланс ≥ 0», «этап по порядку» — ваш слой валидации поверх сходимости (вывод Части III).
  • Права доступа. Кто может писать в документ — обязанность релея и авторизации, не CRDT (граница 1).
  • Большие данные. Реплика целиком на устройстве не про миллиарды строк (граница local-first из первой статьи).
  • Гарантию доставки. Дельта/журнал — про сходимость; что обновление доедет, решает транспорт, про который — Потоки и Очереди (delivery ≠ convergence, вторая статья).

Финальный способ не ошибиться в выборе — не таблица, а тест из жизни: откройте два таба, в одном офлайн отредактируйте, в другом отредактируйте то же, верните сеть. Yjs: оба куска сохранились, соседи догнали дельтой. Automerge: оба куска сохранились, и вы ещё можете посмотреть, где разошлись ветки, потому что история — ваша. Если в каком-то из вариантов один кусок пропал — вы выбрали не библиотеку, а LWW, и это уже была не эта статья.

Инструменты под задачу

Выбор и ревью CRDT-кода — это, по сути, две разные работы, и под каждую свой инструмент серии.

Читать чужой CRDT-код на предмет «а не стал ли сервер судьёй» — самое ценное. Чужой (или свой через полгода) релей легко просматривается глазом, привыкшим к CRUD: вы видите if ($update->timestamp < $current->timestamp) return; и не спотыкаетесь, хотя это ровно «тихо выбросить чужую правку» (граница 3 Части IV). Прогнать диффом и найти блокеры помогает ассистент-ревьюер.

Запрос, который даёт максимум: «вот diff релея — скажи, есть ли тут место, где сервер применяет патч к эталону и отдаёт результат, а не исходное обновление».

Разобрать незнакомый фрагмент применения обновлений построчно (где тут локальная запись, где слияние чужого, где серверный witness) — работа для чат-ассистента.

И проверка руками на пять минут, которая стоит целой статьи: тот самый двух-табовый тест из Части V. Только с Yjs, потом с Automerge, и вы своими глазами увидите разницу «дельта» против «история».

Чек-лист граблей

  1. Выбирать библиотеку по звёздам или размеру бандла. Форма данных (документ против состояния с историей) решает; размер пакета (≈2,3 МБ vs ≈47,5 МБ) — это WASM-таргеты и модель истории, а не качество (Часть I).
  2. Брать Yjs для «состояния с ветвлением и diff-версий». Истории как модели у Yjs нет — останутся снимки, которых для ветки мало; это доделывание руками того, что Automerge даёт из коробки (Часть III).
  3. Брать Automerge для живого совместного текста. Вы платите тяжестью истории и WASM-мостом за функцию, которую в этом месте никто не просил (Часть III).
  4. Путать delta и diff. Yjs-дельта — это «какие операции не видел получатель» (из вектора версий), а не «чем строка отличается от строки»; попытка передать diff двух текстов ломает сходимость (Часть II).
  5. Считать presence (курсоры) частью данных. Awareness летучий и протухающий; если положить курсоры в CRDT-документ — получите tombstones на то, что вообще не должно сохраняться (Часть II).
  6. Решать, что Yjs-релей можно сделать «только транспорт, ноль хранения». Чтобы считать дельту новому участнику, серверу нужно состояние — witness обязателен; честнее сохранять обновления, чем притворяться, что сервер ничего не хранит (Часть II).
  7. Думать, что история Automerge бесплатна. keep every change — это и суперсила, и потолок: год правок = раздутая реплика и медленное первое открытие (Часть III).
  8. Заставлять PHP-релей применять патч к эталону и рассылать результат. С этого кадра релей — server-as-truth, и клиент с невошедшей правкой молча теряет данные; отдавайте журнал/дельту, не вердикт (граница 3, Часть IV).
  9. Отбрасывать обновления «как устаревшие» по серверному времени. Это LWW с обёрткой; сходимость — обязанность типа, а не право сервера (граница 3).
  10. Не проверять права до записи обновления. Формат валидный, значит любой гость зальёт правку в чужой документ; авторизация на уровне документа — обязанность релея (граница 1).
  11. Не ограничивать размер update и частоту сообщений. «Непрозрачные байты» ≠ «безразмерные»: корректный гигантский пакет роняет сервер (граница 2).
  12. Ждать от выбранной библиотеки соблюдения инвариантов. «Один исполнитель», «баланс ≥ 0» не удержит ни Yjs, ни Automerge — это ваш слой валидации (Часть V).
  13. Считать, что дельта/журнал гарантирует доставку. delivery ≠ convergence; что обновление доедет — транспорт и очередь, а не CRDT (Часть V, ссылки на Потоки/Очереди).
  14. Забывать про компакцию при долгоживущем релее. Без сборки мусора лог и новый участник при открытии растут неограниченно — у тонкого PHP-релея есть потолок, и его надо признать (Часть IV).

👤 Зарегистрируйтесь, чтобы добавить материал в закладки.