Первая статья серии оставила вопрос, на котором держится всё остальное. Если правда живёт на устройстве и каждая реплика — полноценная копия, то почему две реплики, принявшие одни и те же изменения в разном порядке, вообще обязаны прийти к одному состоянию? Обычный ответ — «там умный merge» — ничего не объясняет: он подменяет механизм названием. Этот механизм — CRDT, и у него есть точное определение, из которого сразу видны и его сила, и его цена.
Разбираем честно: три свойства, без которых сходимости не будет; четыре базовых типа и что каждый из них теряет; почему доставка всех сообщений ≠ сходимость; откуда берутся метаданные и почему они растут; и где проходит граница, за которой CRDT перестаёт быть выгодным.
Часть I. Задачу нельзя решить «умным merge»
Начнём с того, почему привычная интуиция здесь ломается.
В обычном CRUD-приложении конфликт выглядит как ошибка: две транзакции задели одну строку, база откатила одну, и это правильно — арбитр был. Арбитр — это сервер, у которого есть единая история: он видел оба запроса и вынес решение по порядку.
В local-first арбитра нет по построению. Два устройства правили документ, пока сеть была недоступна. Ни одно из них не знает, что происходило на другом. Когда они наконец свяжутся, у нас есть два набора изменений и нет факта, кто первый. Не «мы не смогли узнать» — этого факта не существует: в физическом мире не было события «правка A раньше правки B», потому что они происходили в разных местах.
Отсюда первый вывод, который стоит принять до всякого кода: задача не в том, чтобы определить правильный порядок. Задача в том, чтобы результат не зависел от порядка. Это и есть вся идея CRDT (Conflict-free Replicated Data Types) — типы данных, у которых операция соединения двух реплик даёт один и тот же результат независимо от того, в каком порядке изменения доехали.
Формулировка «conflict-free» вводит в заблуждение: конфликты есть, их не «устраивают» — их переопределяют так, что они перестают быть конфликтами. Ключевое слово здесь — «переопределяют». Ниже видно, что за каждое такое переопределение платят.
Есть два способа передавать состояние между репликами, и путать их — источник половины недоразумений:
op-based (CmRDT): передаём ОПЕРАЦИИ. Реплика применяет их локально.
Требует надёжного канала доставки каждой операции
каждому участнику ровно один раз (или идемпотентности).
state-based (CvRDT): передаём СОСТОЯНИЕ ЦЕЛИКОМ (или его сжатую форму).
Приёмник делает merge(своё, чужое) и получает новое состояние.
Терпит потерю сообщений, дубли и любой порядок —
но платит объёмом передачи и требует, чтобы состояние
было полурешёткой (см. Часть II).
State-based проще рассуждать: merge — обычная функция над двумя значениями, и её свойства можно проверить в тестах без всякой сети. Именно на неё опирается дальнейший разбор, потому что op-based в реальности всё равно приходит к тому же — либо через надёжную доставку, либо через идемпотентное применение, а идемпотентность и есть свойство merge.
Часть II. Три свойства и полурешётка
Теперь та самая математика. Она короткая, но её нельзя пройти «по касательной»: без неё не понять, ни почему LWW тихо теряет данные, ни почему счётчики нельзя складывать как попало.
Пусть у нас есть множество состояний S и операция merge(a, b). Чтобы две реплики, применившие одни и те же изменения в разном порядке, сошлись, merge должна обладать тремя свойствами:
1. Коммутативность: merge(a, b) = merge(b, a). Порядок, в котором реплики встретились, не влияет на результат.
2. Ассоциативность: merge(merge(a, b), c) = merge(a, merge(b, c)). Не важно, как сгруппировать слияния. Именно это свойство делает возможной передачу «через третьего»: реплика A слилась с B, потом B — с C, и A, слившись с C, получит то же, что получила бы, встретившись со всеми сразу.
3. Идемпотентность: merge(a, a) = a. Повторное применение того же состояния ничего не меняет. Без этого невозможна работа по ненадёжной сети: сообщения дублируются, и дубль не должен ломать состояние.
Если все три выполняются, множество состояний с такой операцией называется полурешёткой (join-semilattice), а merge — операцией соединения. Звучит академично, проверяется просто: это три юнит-теста.
// Свойства merge проверяются как обычные тесты, без сети и без БД.
// Генерируем случайные состояния и проверяем три закона.
function assertSemilattice(merge, samples) {
for (const a of samples) {
// идемпотентность
assert.deepEqual(merge(a, a), a);
for (const b of samples) {
// коммутативность
assert.deepEqual(merge(a, b), merge(b, a));
for (const c of samples) {
// ассоциативность
assert.deepEqual(merge(merge(a, b), c), merge(a, merge(b, c)));
}
}
}
}
Эти несколько строк — самый ценный код во всей теме. Если ваш тип проходит этот тест на случайных состояниях (property-based, сотни прогонов), он сойдётся при любой доставке. Если не проходит — никакой объём тестов «на реальных сценариях» этого не компенсирует: расхождение проявится в проде, на конкретной паре устройств, через неделю.
Почему «порядок не важен» — не то же самое, что «порядок не нужен»
Здесь легко сделать неверный шаг. Из коммутативности не следует, что внутри типа нет порядка. Он есть — и почти всегда нужен. Разница в том, что порядок становится частью самих данных, а не свойством канала доставки.
Пример: текстовый документ, куда двое вставили символ в одну и ту же позицию. Чтобы все реплики показали одинаковый текст, надо решить, чей символ левее. CRDT решает это не «по времени прихода», а по идентификаторам символов: каждый символ получает уникальный идентификатор при рождении, и порядок задаётся сравнением этих идентификаторов. Порядок теперь детерминирован и одинаков на всех репликах, хотя никакой общей истории не было.
Вот это и есть механизм сходимости: не согласование порядка, а перенос порядка в данные. Дальше вся статья — про цену такого переноса.
Часть III. Четыре базовых типа и что каждый теряет
Прежде чем идти к текстовым CRDT, разберём четыре типа, на которых видна вся логика — и вся цена. Каждый пример ниже — законченный state-based тип: у него есть своё состояние и своя merge.
G-Counter: счётчик, который только растёт
Задача: несколько устройств увеличивают общий счётчик (просмотры, отправленные сообщения). Складывать «просто числа» нельзя: если реплика получила старое значение 5 после нового 7, сумма станет неверной.
Решение: у каждой реплики свой слот, и она увеличивает только свой.
состояние G-Counter = { A: 3, B: 5, C: 0 } // по слоту на реплику
значение = 3 + 5 + 0 = 8
merge(a, b) = { k: max(a[k], b[k]) для каждого k }
merge берёт максимум по каждому слоту. Максимум коммутативен, ассоциативен и идемпотентен — свойства выполняются «по построению», их даже не надо доказывать отдельно.
Что теряет: память, пропорциональную числу реплик: слот на каждую, а не одно число. На пяти устройствах это пять счётчиков вместо одного; на тысяче — тысяча. Плюс второе, более важное: счётчик не умеет уменьшаться. dec в G-Counter невозможен в принципе, потому что уменьшение не является монотонным, а полурешётка требует монотонности.
PN-Counter: два счётчика, чтобы уметь в минус
Обходной путь: держим два G-Counter — для прибавлений и для вычитаний.
состояние = { inc: {A:3, B:5}, dec: {A:1, B:0} }
значение = sum(inc) - sum(dec) = (3+5) - (1+0) = 7
merge = merge по каждому из двух счётчиков отдельно
Что теряет: вдвое больше памяти, чем G-Counter (два набора слотов вместо одного), и — важнее — не запрещает уйти в минус. Если реплика A вычла больше, чем видела прибавлений, итог будет отрицательным. Ограничение «баланс ≥ 0» — это инвариант, который CRDT сам не удержит: он живёт на уровне приложения и проверяется отдельно, уже после слияния. Инварианты — отдельная большая тема, к ней вернёмся в Части IV.
LWW-Register: «последний победил» — и почему это тихая потеря
Самое популярное «решение конфликтов» в вебе и самое опасное в этой роли.
состояние = { value, timestamp, replicaId }
merge(a, b):
если a.timestamp > b.timestamp → a
если b.timestamp > a.timestamp → b
иначе (равные метки времени) → сравнить replicaId, взять больший
Порядок задаётся парой (timestamp, replicaId). Дополнительный replicaId нужен как раз для того, чтобы равные метки времени давали детерминированный результат, а не «кто первый пришёл». Это правильная реализация LWW — и именно поэтому видно, что она делает.
Что теряет: всю конкурентную правку, кроме одной. Если двое правили поле, пока были офлайн, — одна правка исчезнет. Не «разрешится не в вашу пользу», а именно исчезнет: её значения нет ни в одной реплике после слияния. Никакого следа, никакого уведомления.
Это допустимо ровно в тех местах, где вы сознательно согласны: цвет темы, размер шрифта, «последняя выбранная вкладка». Это катастрофа для текста документа, корзины покупок или строки в таблице, которую правили вдвоём.
Отдельная ловушка — часы. LWW сравнивает timestamp, а часы на устройствах расходятся: у кого-то сбиты, у кого-то часовой пояс не тот. Поэтому на практике в LWW идут не «время на устройстве», а логические часы (Lamport counter) — и даже тогда LWW остаётся LWW: он не сохраняет проигравшую правку, а только делает выбор детерминированным.
Грабля, с которой начинается большинство инцидентов: LWW выбирают как «самое простое решение», не замечая, что простота оплачена молчаливой потерей данных. Если в интерфейсе нет истории правок, потеря обнаружится через недели — когда пользователь спросит, куда делся абзац.
OR-Set: множество, которое помнит, что удалили
Задача: общий список (теги, участники, задачи). Простое множество не годится: «добавить» и «удалить» одного и того же элемента конкурентно дают разный результат в зависимости от порядка.
Решение: каждый элемент при добавлении получает уникальную метку (обычно replicaId + счётчик), и удаление удаляет не элемент, а конкретные наблюдаемые метки.
состояние = { add: { "тег": {A:1, B:1} }, remove: { "тег": {A:1} } }
элемент присутствует, если в add есть хотя бы одна метка, отсутствующая в remove
merge = объединение множеств меток по каждому элементу (union)
Правило: удаление не может удалить то, чего не видело. Если A удалил метку A:1, а B одновременно добавил метку B:1, после слияния элемент останется — с меткой B:1. Это семантика «add побеждает» для конкурентного случая и «remove работает» для последовательного. Объединение множеств — снова идеальная merge: коммутативна, ассоциативна, идемпотентна.
Что теряет: метки накапливаются. Каждое удаление оставляет след — remove хранит метки навсегда, и это первое место, где появляются tombstones (надгробия), о которых подробно в Части IV.
Сводка потерь
| Тип | Что моделирует | Свойства merge | Чем платите |
|---|---|---|---|
| G-Counter | только растущее число | max по слотам | память на реплику; не умеет уменьшаться |
| PN-Counter | число со знаком | max по двум наборам слотов | память ×2; инвариант «≥ 0» не держит |
| LWW-Register | одно значение | сравнение (ts, replicaId) | конкурентная правка теряется целиком |
| OR-Set | множество | union меток | tombstones растут; память монотонна |
Общий вывод из таблицы: выбор типа — это выбор, какую потерю вы согласны принять. Не «какой тип правильнее», а «какая потеря в этом месте продукта допустима». Для текста документа допустимая потеря — никакая, поэтому там всё сложнее и дороже (см. Часть V).
Часть IV. delivery — не convergence
Теперь самый неочевидный пункт, и он стоит отдельного раздела, потому что его путают чаще всего.
Можно построить систему, которая доставляет все сообщения без потерь, в итоге доставляет каждое ровно один раз — и всё равно приходит к разным состояниям на разных репликах. Доставка и сходимость — два независимых свойства. Выполнение первого не влечёт второго.
Почему: сходимость обеспечивается свойствами операции слияния, а не надёжностью канала. Идеальный транспорт доставит вам все операции в разном порядке на разные устройства. Если merge не коммутативна — порядок решит результат, и реплики разойдутся при полной, стопроцентной доставке.
┌── реплика A получила: [x=1] затем [x=2] → x=2
доставлено│
всё, без │
потерь └── реплика B получила: [x=2] затем [x=1] → x=1
Итог: доставка идеальна, сходимости нет.
Причина: merge не коммутативна (последняя запись побеждает по порядку прихода).
Обратное тоже верно и тоже важно: ненадёжный канал не ломает сходимость, если merge корректна. Потерялось сообщение — состояние сошлось к тому, что успело доехать; пришло повторно — идемпотентность не дала ничего испортить; пришло через третьего участника — ассоциативность сохранила результат. Именно поэтому state-based типы так удобны: они превращают свойство сети из «обязательно» в «желательно».
Практическое следствие для того, кто пишет релей: не пытайтесь «починить» сходимость на транспорте. Очередь с гарантией порядка на сервере выглядит как решение, но она решает не ту задачу: она выпрямляет порядок для тех, кто подключён сейчас, и ничего не даёт устройству, которое вернулось в сеть через сутки со своей пачкой изменений. Сходимость — обязанность типа данных, а релей — обязанность доставки. Смешать их значит получить систему, которая выглядит работающей на тестах с одним клиентом.
Про то, как очереди вообще устроены и почему «гарантия порядка» — отдельное свойство, а не бесплатный бонус, у нас разобрано в «Очередях сообщений». Там же видно, почему порядок в очереди и порядок в состоянии — разные вещи.
Цена первая: tombstones
Вернёмся к OR-Set. Удалённый элемент нельзя просто вычеркнуть: если реплика не видела удаления, она может «воскресить» элемент, слияв своё старое состояние. Поэтому удаление хранится как факт — надгробие.
Отсюда закономерность: память CRDT монотонна. Она не уменьшается от удалений. Документ, который год правили и чистили, весит больше пустого — на размер всей истории удалений. Для текстового CRDT то же самое с удалёнными символами.
Цена вторая: каузальные метаданные
Чтобы понимать, что «уже видел», реплике нужны версии — векторы версий (version vectors): по числу на реплику, с максимальным увиденным счётчиком. Хранится на каждый документ, передаётся при синхронизации.
Масштаб проблемы: вектор растёт с числом реплик (устройств, сессий, вкладок), а не с числом пользователей. Человек с ноутбуком, телефоном и тремя вкладками — это пять записей, которые надо хранить и сравнивать. На десяти устройствах это не проблема; в системе, где каждая вкладка — новая реплика и они не убираются никогда, вектор растёт неограниченно. Отсюда практическое правило: реплики надо уметь «сдавать» — старые, давно синхронизированные идентификаторы удалять из вектора, иначе метаданные съедят экономику.
Цена третья: сборка мусора требует стабильности
Tombstones можно убрать — но только тогда, когда удаление точно никем не будет оспорено. Формально: когда все реплики гарантированно увидели это удаление. Это называется каузальной стабильностью, и вот в чём ловушка: чтобы её установить, нужно знать состояние всех реплик. То есть сборка мусора в CRDT требует того самого глобального знания, от которого CRDT избавлялся.
Выход всегда компромиссный:
- Порог по времени. «Удаления старше 30 дней убираем» — работает, если реплика, отсутствовавшая 31 день, не вернётся. Если вернётся — она «воскресит» удалённое. Это надо принять сознательно и, желательно, ограничить на входе: отклонять синхронизацию от реплик, не выходивших на связь дольше порога, и просить их пересобрать состояние с нуля.
- Сервер как арбитр стабильности. Сервер знает, кто подключён и что подтвердил. Тогда он может сказать: «эти удаления видели все активные реплики». Это уже не «сервер-судья по содержанию», но сервер, ведущий учёт — тонкая, но реальная передача полномочий. Честнее называть это так, чем делать вид, что сервер по-прежнему ничего не решает.
- Не убирать вовсе. Для документов человеческого размера (заметка, страница, таблица на тысячи строк) это часто разумный выбор: рост метаданных медленный, а сложность сборки мусора — высокая. Хуже всего этот выбор для долгоживущих списков с частой ротацией (очереди задач, ленты).
Цена четвёртая: инварианты не держатся сами
Самый недооценённый пункт. CRDT гарантирует сходимость, а не корректность. Полурешётка сойдётся к состоянию, которое может нарушать бизнес-правила:
- «Баланс не может быть отрицательным» — PN-Counter не удержит (Часть III).
- «У задачи не больше одного исполнителя» — OR-Set такого ограничения не знает: конкурентное назначение двух разных людей даст обоих.
- «Порядок этапов фиксирован» — слияние может дать состояние, где этап 3 выполнен, а этап 2 нет.
Это не дефект конкретной библиотеки, это свойство подхода: инвариант — глобальное утверждение, а слияние — локальная операция без права отказать. Единственные рабочие варианты:
- Ослабить инвариант до того, что CRDT умеет. «Баланс ≥ 0» → «отрицательный баланс подсвечивается и требует ручного разбора». Часто это оказывается приемлемо и лучше, чем блокировки.
- Вынести инвариант в отдельный слой поверх. Состояние сходится, а валидатор периодически его проверяет и поднимает флаги. Это уже не «CRDT решает всё», а «CRDT решает сходимость, приложение — правила».
- Не позволять операциям, ломающим инвариант, быть конкурентными. Если «списать деньги» обязано проходить через сервер с блокировкой — значит, это место остаётся server-as-truth. Local-first в системе бывает островами, и это нормально (об этом была грабля 08 в первой статье).
Часть V. От типов к библиотекам и к PHP-релею
Базовые типы из Части III покрывают счётчики, флаги и множества. Текст документа — отдельная история: тут нужна не сходимость «какого-то значения», а сходимость последовательности символов, где каждая вставка и удаление меняют позиции всех последующих.
Механика у всех текстовых CRDT одна и та же по идее: каждый символ получает уникальный идентификатор при рождении, порядок в документе задаётся сравнением идентификаторов, а не позицией в массиве. Конкурентные вставки в одну позицию разрешаются сравнением идентификаторов — детерминированно и одинаково на всех репликах. Отличаются реализации тем, как они хранят эти идентификаторы, и это отличие определяет всё практическое.
Yjs и Automerge: разница не в «лучше/хуже», а в форме данных
Обе библиотеки — MIT, обе зрелые, обе решают сходимость текста. Версии пересняты в день написания этой статьи (17.11.2026) из реестра npm:
| Yjs | Automerge | |
|---|---|---|
| Версия | 13.6.33 | @automerge/automerge 3.5.0 |
| Лицензия | MIT | MIT |
| Ядро | чистый JS | Rust-ядро, скомпилированное в WASM |
| Размер пакета в npm (распакованный) | ≈2,3 МБ | ≈47,5 МБ |
| Форма данных | текст и вложенные структуры документа | произвольный JSON-подобный стейт |
| История | снимки (Y.snapshot), но не первоклассная история | изменения как объекты, ветвление |
Размер пакета — не «Automerge хуже». Он платит за WASM-сборки под разные таргеты (браузер, Node, workerd, base64-варианты) и за то, что умеет больше по части истории. Но если вы выбираете библиотеку по принципу «возьму ту, что больше звёзд на GitHub», вы пропускаете главный вопрос: какая форма данных у вас на самом деле.
Практическое различие, которое видно сразу:
- Текст документа, присутствие курсоров, быстрые мелкие правки — Yjs оптимизирован именно под это: delta-кодирование, компактность, готовый протокол синхронизации (
y-protocols) и референсный сервер (y-websocket). Automerge это тоже умеет — но через WASM-мост, и с более тяжёлым состоянием. - Произвольный стейт с ветвлением и историей — Automerge ближе: изменения — первоклассные объекты, ветки, возможность пройти историю как в git. У Yjs есть снимки (
Y.snapshot,encodeSnapshot), то есть возможность посмотреть прошлое состояние, но история не является основной моделью и ветвления в ней нет — библиотека про актуальное состояние документа.
Подробный выбор с разбором кода и сценариев — в третьей статье серии: Yjs против Automerge на практике. Здесь важно только одно: обе библиотеки — CRDT, то есть обе принимают цену из Части IV. Ни одна не отменяет tombstones, не отменяет метаданные и не держит инварианты за вас.
Сервер на PHP: что он имеет право делать
Первая статья сказала: сервер становится транспортом и зеркалом. Для CRDT это можно сформулировать точнее, потому что механизм теперь известен.
Релею запрещено решать, какая правка правильная. Как только он начинает «применять патч к эталону» и рассылать результат, он становится server-as-truth с кэшем на клиенте: клиент, чьё изменение не вошло в эталон, тихо теряет правку. Это не гипотетический риск — это самая естественная реализация, если писать релей по привычке от CRUD.
Что релей имеет право делать:
- Хранить и пересылать непрозрачные обновления. Байты в бинарном формате библиотеки, без разбора содержимого. Релей не обязан понимать, что внутри, — и не должен.
- Отдавать историческое состояние новому участнику. Для Yjs —
Y.encodeStateAsUpdate(doc)для полного состояния иY.encodeStateAsUpdate(doc, stateVector)для дельты, гдеstateVectorстроится из уже известного получателю черезY.encodeStateVector(remoteDoc). Релей складывает обновления, но не «схлопывает» их по своему усмотрению. - Ограничивать ресурсы. Размер обновления, частота, число подключений. Это единственная защита от того, что клиент пришлёт корректный по формату, но гигантский по объёму пакет.
- Проверять право доступа. Аутентификация на уровне документа — обязанность релея, потому что больше её взять некому.
Что он не имеет права: отбрасывать обновления «как устаревшие» по своему усмотрению, пересобирать состояние в свой формат и рассылать его, разрешать конфликты «по времени на сервере».
Схема на PHP-релее — тонкая: сокет, таблица «документ → список обновлений», рассылка подключённым. Обязательно — те же меры, что для любого публичного сокета: проверка происхождения, лимит размера кадра, таймаут простоя, потолок числа соединений на пользователя. Про сам транспорт (SSE против WebSocket, когда что выбрать) — в статье «Потоки в браузере».
Одно честное предупреждение по масштабу: PHP-релей с таблицей обновлений — это не Kafka и не «бесконечная история». Для документа, который правят десять человек, этого достаточно с запасом. Для документа с тысячами правок в час нужна компакция (та самая сборка мусора из Части IV) — и это уже отдельная инженерная задача, а не «поставим библиотеку».
Инструменты под задачу
Когда смотрите на чужой CRDT-код — свой через полгода или из библиотеки, — самое полезное, что можно сделать, это разобрать его построчно словами: где тип состояния, где merge, где применяется удалённое обновление, а где (не дай бог) сервер «решает». Разобрать незнакомый фрагмент и назвать каждый шаг помогает ассистент.
Конкретный запрос, который даёт максимум: «вот функция applyUpdate, назови, какие свойства сходимости она обеспечивает, и что произойдёт, если применить два обновления в обратном порядке».
И проверка руками, которая стоит пяти минут: возьмите два таба браузера с одним документом Yjs, отключите сеть в одном, поправьте текст в обоих, включите сеть. Если оба текста сохранились — перед вами настоящий CRDT. Если один исчез — это LWW с красивой обёрткой, и вы только что потеряли данные в контролируемых условиях, а не в проде.
Чек-лист граблей
- Искать «правильный порядок» событий вместо независимости от порядка. В распределённой системе факта «кто первый» не существует; задача — сделать результат независимым от порядка (Часть I).
- Считать, что «умный merge» достаточно. Merge обязана быть коммутативной, ассоциативной и идемпотентной. Иначе сходимости нет ни при какой надёжности канала (Часть II).
- Путать
deliveryиconvergence. Идеальная доставка при некоммутативной merge даёт расхождение; плохая доставка при корректной merge — не даёт (Часть IV). - Пытаться починить сходимость в очереди или на релее. Порядок в транспорте не помогает устройству, вернувшемуся через сутки со своей пачкой изменений (Часть IV).
- Брать LWW «потому что просто». Он теряет конкурентную правку целиком и молча. Допустим только там, где потеря осознанно приемлема: скалярные настройки, а не текст и не корзина (Часть III).
- Верить, что LWW с
timestampрешает проблему часов. Сбитые часы превращают «последний победил» в «случайный победил»; нужны логические часы, и даже тогда теряется проигравшая правка (Часть III). - Забывать про tombstones. Память CRDT монотонна: удаления не освобождают место. Документ с историей чисток больше пустого (Часть IV).
- Пускать рост version vector без ограничений. Вектор растёт по числу реплик (устройств и сессий), а не пользователей. Реплики надо уметь «сдавать» (Часть IV).
- Собирать мусор без каузальной стабильности. Удаление tombstones по времени «воскресит» правки у реплики, отсутствовавшей дольше порога — это решение, а не баг, и его надо принять явно (Часть IV).
- Ждать от CRDT соблюдения инвариантов. «Баланс ≥ 0», «один исполнитель», «порядок этапов» — не его работа. Инвариант либо ослабляется, либо проверяется слоем сверху, либо это место остаётся server-as-truth (Часть IV).
- Складывать счётчики «просто числами». G-Counter хранит слот на реплику и берёт максимум по слоту; сложение двух итогов даёт неверную сумму после слияния (Часть III).
- Удалять в OR-Set целиком, а не по наблюдаемым меткам. Удаление снимает только те метки, которые реплика видела; иначе конкурентное добавление будет потеряно — и элемент исчезнет у всех, хотя его добавляли (Часть III).
- Выбирать библиотеку по популярности. Yjs и Automerge — обе CRDT, обе MIT, но форма данных разная: текст/документ против произвольного стейта с историей (Часть V).
- Заставлять PHP-релей «применять патч к эталону». С этого момента релей — server-as-truth, а клиент с невошедшей правкой теряет данные (Часть V).
- Мерить качество CRDT-слоя тестами «на сценариях». Свойства проверяются property-based тестами на случайных состояниях; сценарии не покрывают комбинации порядков (Часть II).
👤 Зарегистрируйтесь, чтобы добавить материал в закладки.
