CRDT без магии: сходимость без согласования — и за что платишь

Первая статья серии оставила вопрос, на котором держится всё остальное. Если правда живёт на устройстве и каждая реплика — полноценная копия, то почему две реплики, принявшие одни и те же изменения в разном порядке, вообще обязаны прийти к одному состоянию? Обычный ответ — «там умный 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 избавлялся.

Выход всегда компромиссный:

  1. Порог по времени. «Удаления старше 30 дней убираем» — работает, если реплика, отсутствовавшая 31 день, не вернётся. Если вернётся — она «воскресит» удалённое. Это надо принять сознательно и, желательно, ограничить на входе: отклонять синхронизацию от реплик, не выходивших на связь дольше порога, и просить их пересобрать состояние с нуля.
  2. Сервер как арбитр стабильности. Сервер знает, кто подключён и что подтвердил. Тогда он может сказать: «эти удаления видели все активные реплики». Это уже не «сервер-судья по содержанию», но сервер, ведущий учёт — тонкая, но реальная передача полномочий. Честнее называть это так, чем делать вид, что сервер по-прежнему ничего не решает.
  3. Не убирать вовсе. Для документов человеческого размера (заметка, страница, таблица на тысячи строк) это часто разумный выбор: рост метаданных медленный, а сложность сборки мусора — высокая. Хуже всего этот выбор для долгоживущих списков с частой ротацией (очереди задач, ленты).

Цена четвёртая: инварианты не держатся сами

Самый недооценённый пункт. CRDT гарантирует сходимость, а не корректность. Полурешётка сойдётся к состоянию, которое может нарушать бизнес-правила:

  • «Баланс не может быть отрицательным» — PN-Counter не удержит (Часть III).
  • «У задачи не больше одного исполнителя» — OR-Set такого ограничения не знает: конкурентное назначение двух разных людей даст обоих.
  • «Порядок этапов фиксирован» — слияние может дать состояние, где этап 3 выполнен, а этап 2 нет.

Это не дефект конкретной библиотеки, это свойство подхода: инвариант — глобальное утверждение, а слияние — локальная операция без права отказать. Единственные рабочие варианты:

  1. Ослабить инвариант до того, что CRDT умеет. «Баланс ≥ 0» → «отрицательный баланс подсвечивается и требует ручного разбора». Часто это оказывается приемлемо и лучше, чем блокировки.
  2. Вынести инвариант в отдельный слой поверх. Состояние сходится, а валидатор периодически его проверяет и поднимает флаги. Это уже не «CRDT решает всё», а «CRDT решает сходимость, приложение — правила».
  3. Не позволять операциям, ломающим инвариант, быть конкурентными. Если «списать деньги» обязано проходить через сервер с блокировкой — значит, это место остаётся server-as-truth. Local-first в системе бывает островами, и это нормально (об этом была грабля 08 в первой статье).

Часть V. От типов к библиотекам и к PHP-релею

Базовые типы из Части III покрывают счётчики, флаги и множества. Текст документа — отдельная история: тут нужна не сходимость «какого-то значения», а сходимость последовательности символов, где каждая вставка и удаление меняют позиции всех последующих.

Механика у всех текстовых CRDT одна и та же по идее: каждый символ получает уникальный идентификатор при рождении, порядок в документе задаётся сравнением идентификаторов, а не позицией в массиве. Конкурентные вставки в одну позицию разрешаются сравнением идентификаторов — детерминированно и одинаково на всех репликах. Отличаются реализации тем, как они хранят эти идентификаторы, и это отличие определяет всё практическое.

Yjs и Automerge: разница не в «лучше/хуже», а в форме данных

Обе библиотеки — MIT, обе зрелые, обе решают сходимость текста. Версии пересняты в день написания этой статьи (17.11.2026) из реестра npm:

YjsAutomerge
Версия13.6.33@automerge/automerge 3.5.0
ЛицензияMITMIT
Ядрочистый JSRust-ядро, скомпилированное в 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.

Что релей имеет право делать:

  1. Хранить и пересылать непрозрачные обновления. Байты в бинарном формате библиотеки, без разбора содержимого. Релей не обязан понимать, что внутри, — и не должен.
  2. Отдавать историческое состояние новому участнику. Для Yjs — Y.encodeStateAsUpdate(doc) для полного состояния и Y.encodeStateAsUpdate(doc, stateVector) для дельты, где stateVector строится из уже известного получателю через Y.encodeStateVector(remoteDoc). Релей складывает обновления, но не «схлопывает» их по своему усмотрению.
  3. Ограничивать ресурсы. Размер обновления, частота, число подключений. Это единственная защита от того, что клиент пришлёт корректный по формату, но гигантский по объёму пакет.
  4. Проверять право доступа. Аутентификация на уровне документа — обязанность релея, потому что больше её взять некому.

Что он не имеет права: отбрасывать обновления «как устаревшие» по своему усмотрению, пересобирать состояние в свой формат и рассылать его, разрешать конфликты «по времени на сервере».

Схема на PHP-релее — тонкая: сокет, таблица «документ → список обновлений», рассылка подключённым. Обязательно — те же меры, что для любого публичного сокета: проверка происхождения, лимит размера кадра, таймаут простоя, потолок числа соединений на пользователя. Про сам транспорт (SSE против WebSocket, когда что выбрать) — в статье «Потоки в браузере».

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

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

Когда смотрите на чужой CRDT-код — свой через полгода или из библиотеки, — самое полезное, что можно сделать, это разобрать его построчно словами: где тип состояния, где merge, где применяется удалённое обновление, а где (не дай бог) сервер «решает». Разобрать незнакомый фрагмент и назвать каждый шаг помогает ассистент.

Конкретный запрос, который даёт максимум: «вот функция applyUpdate, назови, какие свойства сходимости она обеспечивает, и что произойдёт, если применить два обновления в обратном порядке».

И проверка руками, которая стоит пяти минут: возьмите два таба браузера с одним документом Yjs, отключите сеть в одном, поправьте текст в обоих, включите сеть. Если оба текста сохранились — перед вами настоящий CRDT. Если один исчез — это LWW с красивой обёрткой, и вы только что потеряли данные в контролируемых условиях, а не в проде.

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

  1. Искать «правильный порядок» событий вместо независимости от порядка. В распределённой системе факта «кто первый» не существует; задача — сделать результат независимым от порядка (Часть I).
  2. Считать, что «умный merge» достаточно. Merge обязана быть коммутативной, ассоциативной и идемпотентной. Иначе сходимости нет ни при какой надёжности канала (Часть II).
  3. Путать delivery и convergence. Идеальная доставка при некоммутативной merge даёт расхождение; плохая доставка при корректной merge — не даёт (Часть IV).
  4. Пытаться починить сходимость в очереди или на релее. Порядок в транспорте не помогает устройству, вернувшемуся через сутки со своей пачкой изменений (Часть IV).
  5. Брать LWW «потому что просто». Он теряет конкурентную правку целиком и молча. Допустим только там, где потеря осознанно приемлема: скалярные настройки, а не текст и не корзина (Часть III).
  6. Верить, что LWW с timestamp решает проблему часов. Сбитые часы превращают «последний победил» в «случайный победил»; нужны логические часы, и даже тогда теряется проигравшая правка (Часть III).
  7. Забывать про tombstones. Память CRDT монотонна: удаления не освобождают место. Документ с историей чисток больше пустого (Часть IV).
  8. Пускать рост version vector без ограничений. Вектор растёт по числу реплик (устройств и сессий), а не пользователей. Реплики надо уметь «сдавать» (Часть IV).
  9. Собирать мусор без каузальной стабильности. Удаление tombstones по времени «воскресит» правки у реплики, отсутствовавшей дольше порога — это решение, а не баг, и его надо принять явно (Часть IV).
  10. Ждать от CRDT соблюдения инвариантов. «Баланс ≥ 0», «один исполнитель», «порядок этапов» — не его работа. Инвариант либо ослабляется, либо проверяется слоем сверху, либо это место остаётся server-as-truth (Часть IV).
  11. Складывать счётчики «просто числами». G-Counter хранит слот на реплику и берёт максимум по слоту; сложение двух итогов даёт неверную сумму после слияния (Часть III).
  12. Удалять в OR-Set целиком, а не по наблюдаемым меткам. Удаление снимает только те метки, которые реплика видела; иначе конкурентное добавление будет потеряно — и элемент исчезнет у всех, хотя его добавляли (Часть III).
  13. Выбирать библиотеку по популярности. Yjs и Automerge — обе CRDT, обе MIT, но форма данных разная: текст/документ против произвольного стейта с историей (Часть V).
  14. Заставлять PHP-релей «применять патч к эталону». С этого момента релей — server-as-truth, а клиент с невошедшей правкой теряет данные (Часть V).
  15. Мерить качество CRDT-слоя тестами «на сценариях». Свойства проверяются property-based тестами на случайных состояниях; сценарии не покрывают комбинации порядков (Часть II).

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