letopis 0.13.0 → 0.16.0

package/README.md

@@ -13,7 +13,7 @@ const пути = await db.Сотрудник({ name: 'Вася' }).навык().
 // [ { Сотрудник: Row, навык: Row, Услуга: Row }, … ]
 
 // запись: операции — звенья, исполняет терминал
-await db.Организация(org).Сотрудник().set({ name: 'Вася', roles: ['master'] }).rows()
+await db.Организация(org).Сотрудник().create({ name: 'Вася', roles: ['master'] }).rows()
 ```
 
 Содержание:
@@ -52,8 +52,8 @@ const db = await up({ schema: 'booking', version: 1 })   // → PG-схема "v
 // [letopis.up] schema "v1.booking" applied (3 files)
 // [letopis.up] connected (schema "v1.booking")
 
-const [org]  = await db.Организация().set({ name: 'BarberPro' }).rows()
-const [вася] = await db.Организация(org).Сотрудник().set({ name: 'Вася', roles: ['master'] }).rows()
+const [org]  = await db.Организация().create({ name: 'BarberPro' }).rows()
+const [вася] = await db.Организация(org).Сотрудник().create({ name: 'Вася', roles: ['master'] }).rows()
 await db.close()
 ```
 
@@ -108,7 +108,7 @@ const db = await connect({ dsn: 'postgres://postgres:test@localhost:15432/clockz
 
 | SQL | Триггер | Поведение |
 |---|---|---|
-| `INSERT` | `entity_check` | класс существует (плюс FK) и не abstract; ключи `links` — существующие классы, значения — строки-id; у LINK есть обязательные концы (`'Entity'`-концы полиморфны — закрывает либа). Tombstone-вставки не проверяются |
+| `INSERT` | `entity_check` | класс существует (плюс FK) и не abstract; ключи `links` — существующие классы, значения — строки-id; концы LINK по Schema.links v2 (жадный матчинг, союзы, optional, лишние связи — ошибка; legacy-строки — по-старому). Tombstone-вставки не проверяются |
 | `UPDATE` | `entity_update` | физического апдейта нет: вставляется **новая версия** (`updated = GREATEST(clock, prev+1µs)`); не-latest строки игнорируются — история неизменна |
 | `DELETE` | `entity_delete` | вставляется **tombstone** + **рекурсивный каскад**: DELETE живых зависимых (`links ⊃ {класс: id}`) повторяет триггер по дереву; advisory-lock; история/tombstone неприкосновенны (повторный DELETE — no-op) |
 
@@ -148,13 +148,79 @@ GIN-кандидатам, затем перепроверка условий н
 | `ancestor` | прямой родитель |
 | `ancestors` | `[self, parent, …, root]` — **считает триггер `schema_lineage`** |
 | `descendants` | все потомки транзитивно — **тот же триггер** |
-| `attributes` | [fastest-validator](https://github.com/icebob/fastest-validator) DSL; вложенные `{type:'object', props:{…}}` любой глубины; строгая валидация |
-| `links` | HUB: встраиваемые цели (forward-обход); LINK: обязательные концы, `'Entity'` = полиморфный |
+| `attributes` | [fastest-validator](https://github.com/icebob/fastest-validator) DSL; вложенные `{type:'object', props:{…}}` любой глубины; строгая валидация; собираются по иерархии (§ 3.3); правило `id` — генерация (§ 3.2) |
+| `links` | концы связей класса, формат v2 — массив объектов (см. ниже); legacy-строка `'Org'` = `{class:'Org'}`, `'Entity'` = старый полиморф |
 | `meta` | `{ abstract?, description? }` |
 
+### 3.1 Концы связей — Schema.links v2
+
+Каждый конец — объект (`Schema.links jsonb` — массив объектов):
+
+```jsonc
+"links": [
+  { "class": "Booking", "cardinality": 1 },                  // один класс
+  { "classes": ["Service", "Complex"], "cardinality": 1 },   // союз ролей: ровно один из
+  { "class": "Staff", "optional": true, "cardinality": 1 }   // конец может отсутствовать
+]
+```
+
+- `Entity` в концах не используется — классы называются явно («максимально точная идентификация связи»)
+- **Матчинг жадный, по порядку объявления**: каждый ключ `Entity.links` строки занимает первый подходящий конец. Союз ролей: предмет позиции — `{Услуга|Комплекс}` (заказ услуги ИЛИ заказ комплекса — ровно один из)
+- Обязательный конец без ключа → `requires end "Service|Complex"`; связь вне объявленных концов → `stray link(s)` — **ошибки и в либе, и в БД-триггере** (голый SQL ловится так же)
+- `cardinality` — зарезервировано (0 — безлимит, N — точное число), пока не проверяется: связь класса в строке одна (`{Класс: id}`), множественность выражается строками-связками
+- Демо-домен: `позиция = [Запись, {Услуга|Комплекс}, Сотрудник?]`, `состав = [Комплекс, Услуга]` (состав комплекса — отдельный LINK), `навык = [Сотрудник, {Услуга|Комплекс}]`, `занятость = [Сотрудник, Окно, Запись?]`, `смена = [Расписание, Сотрудник]`, `Запись = [Клиент?]`
+- Источник правды — `schema.booking.v2.json`; сид генерится: `node lib/scripts/gen-seed.mjs`
+
 `schema_lineage` (statement-триггер, рекурсивные CTE, защита от циклов/саморекурсии)
 пересчитывает `ancestors`/`descendants` при любом изменении Schema.
-Из либы: `db.registry.resolve('связь').descendants` → `['busy','item','shift','skill']`.
+Из либы: `db.registry.resolve('связь').descendants` → `['busy','compo','item','shift','skill']`.
+
+### 3.2 id считает схема: `attributes.id`
+
+Правило рождения id объявляется в `attributes.id` класса (наследуется — § 3.3):
+
+| Правило | Версия | Смысл |
+|---|---|---|
+| `"uuid"` / `{"type":"uuid"}` | **v4** | random — дефолт (как раньше) |
+| `{"type":"uuid","generate":7}` | **v7** | unix-время в старших битах — вставки ложатся в хвост btree-индекса |
+| `{"type":"uuid","generate":5,"from":[…]}` | **v5** | детерминированный: id вычисляется из данных |
+
+Формула v5 открыта: `uuidv5("pgSchema:partition:класс:значения from")`, namespace letopis —
+`c7a2f9d4-3b61-4e8a-9f05-8d2c1e6b7a90`. `from` — имена ОБЯЗАТЕЛЬНЫХ концов `Schema.links`
+(класс или полное имя союза `'Service|Complex'`; значение — id конца) и/или скалярных полей
+`data`. Экспорт: `import { uuidv5, uuidv7, LETOPIS_NS } from 'letopis'`.
+
+Два свойства v5, ради которых всё:
+
+- **create идемпотентен**: та же комбинация → та же сущность (повтор — новая версия, не
+  дубль) — даже в гонке двух процессов оба вычислят один id; двойная бронь мертва на
+  уровне схемы;
+- **id известен ДО создания**: «занято ли окно» — точечный `first()` по вычисленному id,
+  без создания чего-либо.
+
+```ts
+// занятость: id считается сам — uuidv5(окно, мастер)
+const [б] = await db.Сотрудник(м).занятость().create({ kind: 'booking' }).Окно.set(о).rows()
+б.id === uuidv5(`v1.booking:entity:busy:${о.id}:${м.id}`)   // → true
+// «занято?» — ДО создания чего-либо:
+await db.занятость(uuidv5(`v1.booking:entity:busy:${о.id}:${м.id}`)).first()   // Row | null
+```
+
+Явный id у v5-класса запрещён (`computes id` — его всегда считает схема); в батче
+v5-классы не склеиваются в multi-VALUES (id нужны концы) — исполняются поштучно (§ 8).
+
+Демо-схема booking: корни `Entity`/`link` объявляют дефолт `{generate: 7}` один раз;
+v7-классы (Org/Staff/Folder/Customer/Schedule/Booking/item) наследуют его без собственного
+правила; v5 переопределяют: `busy ← v5(Slot, Staff)`, `skill ← v5(Staff, Service|Complex)`,
+`shift ← v5(Schedule, Staff)`, `compo ← v5(Complex, Service)`, `Slot ← v5(Schedule,
+data.start)`, `Service`/`Complex` ← `v5(Org, data.name)` — имя уникально в организации.
+
+### 3.3 Наследование attributes
+
+При загрузке реестра attributes класса собираются по цепочке `ancestor`: **потомок ПОВЕРХ
+предка**, переопределение поля — замена правила ЦЕЛИКОМ (не слияние). Правило `id` (§ 3.2)
+наследуется так же — дефолт объявляется один раз на корне иерархии; `links` НЕ наследуются:
+концы объявляет каждый класс сам. Валидатор и типы полей компилируются из слитых attributes.
 
 ---
 
@@ -169,6 +235,26 @@ GIN-кандидатам, затем перепроверка условий н
 | HUB → HUB (разные) | forward, если цель ∈ `Schema.links` текущего; иначе reverse; иначе «no path» |
 | HUB → HUB (тот же класс) | reverse = **дети** (`db.Папка(id).Папка()`); родитель — `row.links.Folder` |
 | LINK → LINK | ошибка |
+| повтор LINK-класса | **pivot**: возврат к тому же узлу (ветвление к другому концу + дофильтр AND) |
+
+Путь подчиняется переходам **всегда** — и в чтении, и в записи; недопустимый переход —
+ошибка **синхронно при построении цепочки** (не в терминале). К концу связки, до которого
+прямого HUB→HUB пути нет, идут через саму связку и **pivot** (повтор её имени):
+
+```ts
+// «позиции записи з, где услуга у и мастер вася» — путь через позицию, pivot-возврат:
+db.Запись(з).позиция().Услуга(у).позиция().Сотрудник(вася).позиция().rows()
+// «умеет ли Ирина стрижку» — навык, дофильтр предметом, count путей:
+db.Сотрудник(ирина).навык().Услуга(стрижка).навык().count()   // 0 | 1
+```
+
+### Узел-переменная: `entity()`
+
+```ts
+const p = db.позиция()                                        // ленивый узел-паттерн
+await db.Запись(з).entity(p).Услуга(у).entity(p).Сотрудник().run() // та же p = тот же узел (явный pivot)
+await db.entity(row).Услуга().first()                         // старт пути с готового Row
+```
 
 ### Терминалы
 
@@ -244,88 +330,112 @@ db.Организация().owner(acc)                 // фильтр по owne
 db.Сотрудник({…}).alias('Мастер')           // ключ шага в путях
 ```
 
-| Модификатор | Область | В чтении | В `set()` |
+| Модификатор | Область | В чтении | В записи |
 |---|---|---|---|
-| `limit(n)` / `offset(n)` / `sort(field, dir?)` | вся цепочка | LIMIT/OFFSET/ORDER BY | ограничивает набор целей UPDATE |
+| `limit(n)` / `offset(n)` / `sort(field, dir?)` | вся цепочка | LIMIT/OFFSET/ORDER BY | ограничивает набор целей `update()` |
 | `asOf(t)` | вся цепочка | «как было на T» (§ 10.1) | — |
 | `after(cursor)` | вся цепочка | keyset-пагинация, требует `sort` (§ 10.2) | — |
 | `deep(max?)` | текущий шаг (self-hop) | рекурсивные дети, `$depth` (§ 10.4) | — |
-| `tags(v)` | текущий шаг | фильтр по колонке | **значение** тегов при INSERT (string \| string[]) |
-| `account(v)` / `owner(v)` | текущий шаг | фильтр по колонке | **значение** при INSERT |
-| `link(Класс, target)` | текущий шаг | — | **значение** связи БЕЗ участия в фильтре целей (§ 6) |
+| `tags(v)` | текущий шаг | фильтр по колонке | **значение** тегов при `create()` (string \| string[]) |
+| `account(v)` / `owner(v)` | текущий шаг | фильтр по колонке | **значение** при `create()` |
+| `.Класс.set(x)` / `.Класс.unset()` | слот связи — после глагола записи | — | записать / снять конец связи БЕЗ участия в фильтре целей (§ 6.1) |
 | `alias(name)` | текущий шаг | ключ в путях | — |
 
 ---
 
 ## 6. Запись: операции — звенья плана
 
-`.set(data)` / `.delete(opts)` / `.anonymize(fields)` — **звенья цепочки**: операция
-применяется к шагу, к которому приклеена точкой, и возвращает цепочку для продолжения.
-Сама по себе ничего не пишет — **исполняет терминал** (`rows()/first()/count()/run()/…`),
-весь план **одной транзакцией**: отказ любого сегмента (валидация, ACL) откатывает всё.
+`.create(data?)` / `.update(data?)` / `.delete(opts?)` / `.anonymize(fields)` — **звенья
+цепочки**: операция применяется к шагу, к которому приклеена точкой, и возвращает цепочку
+для продолжения. Сама по себе ничего не пишет — **исполняет терминал**
+(`rows()/first()/count()/run()/…`), весь план **одной транзакцией**: отказ любого сегмента
+(валидация, ACL) откатывает всё.
+
+Глаголы не перепутать: `create` **вставляет** (или версионирует по известному id),
+`update` **правит найденное путём** и никогда не создаёт. Старый `set()` разбит на них
+в 0.16.0 (бросает подсказку) — мина «`Класс()` → INSERT, `Класс({})` → UPDATE всех» мертва,
+намерение всегда явное.
 
 ```ts
 // одиночная запись: операция + терминал
-const [вася] = await db.Организация(org).Сотрудник().set({ name: 'Вася', roles: ['master'] }).rows()
+const [вася] = await db.Организация(org).Сотрудник().create({ name: 'Вася', roles: ['master'] }).rows()
 
 // несколько операций в одной цепочке: продолжение — ОТ РЕЗУЛЬТАТА предыдущей
-await db.Клиент({ vip: true }).set({ bonus: 500 })       // UPDATE всех vip
-        .Запись().set({ status: 'gift' })                // INSERT записи КАЖДОМУ (fan-out)
+await db.Клиент({ vip: true }).update({ bonus: 500 })    // новая версия всех vip
+        .Запись().create({ status: 'gift' })             // INSERT записи КАЖДОМУ (fan-out)
         .rows()                                          // → подарочные записи
 
 // операция сразу после операции — к тем же сущностям (две версии подряд)
-await db.Запись(id).set({ status: 'confirmed' }).set({ paid: true }).rows()
+await db.Запись(id).update({ status: 'confirmed' }).update({ paid: true }).rows()
 ```
 
 ### Анатомия
 
 ```
-db.Ктx1(id).Ктx2(id).Класс( ФИЛЬТР ).set( DATA ).Хвост()… .rows()
-   └───── контекст ─────┘   └─────┘       └─ продолжение ─┘ └─ терминал: исполняет план
-    каждый шаг = связь      кого трогаем    от записанных
+db.Ктx1(id).Ктx2(id).Класс( ФИЛЬТР ).глагол( DATA ).Хвост()… .rows()
+   └───── контекст ─────┘   └─────┘  └────┘         └─ продолжение ─┘ └─ терминал: исполняет план
+    каждый шаг = связь   кого трогаем  create|update|delete  от записанных
+                         (только update)
 ```
 
 - **Контекст-шаги** (шаги до операции): каждый резолвится в **ровно одну** сущность —
   id-фильтром (без запроса) или уникальным фильтром (0 или >1 → ошибка). Дают: `links`
-  при INSERT и containment-фильтр целей при UPDATE/DELETE.
-- **ФИЛЬТР шага операции** — режим:
+  при `create` и containment-фильтр целей при `update`/`delete`.
+- **Режим выбирает глагол** (фильтр-объект допустим только перед `update`):
 
-| Фильтр шага операции | data.id | Действие |
+| Глагол | Шаг операции | Действие |
 |---|---|---|
-| `Класс()` — без аргумента | нет | **INSERT** (id = uuid), links = контекст |
-| `Класс()` — без аргумента | есть | **UPSERT** по `data.id` |
-| `Класс('id')` — строка | — | **UPSERT** по этому id |
-| `Класс({...поля})` — объект | — | **UPDATE**: новая версия каждого найденного (в границах контекста); пусто → `[]` |
-| `Класс({})` — **пустой объект** | — | **UPDATE всех** в границах контекста |
+| `create(data?)` | `Класс()` — без фильтра | **INSERT**: id по правилу схемы (§ 3.2), links = контекст + слоты |
+| | `Класс(id)` / `data.id` / вычисленный v5-id **уже существует** | **новая версия** (идемпотентный create, REST-PUT семантика); не существует → INSERT с этим id |
+| | `Класс({фильтр})` | ошибка ПОСТРОЕНИЯ `create() takes no filter`; create на pivot-шаге — тоже ошибка |
+| `update(data?)` | `Класс()` ≡ `Класс({})` | новая версия **всех** в границах контекста |
+| | `Класс(id)` / `Класс({поля})` / pivot | новая версия **каждого** найденного путём; не найдено → `[]` — update НИКОГДА не создаёт |
 
-- **Продолжение после операции** — от её результата: класс-шаг = переход (INSERT-цель
+- **Продолжение после операции** — от её результата: класс-шаг = переход (create-цель
   следующего сегмента получает связь на записанное; чтение — обычный hop). При
   множественном результате следующий сегмент исполняется **для каждой строки** (fan-out).
   После `delete` продолжение идёт от строк класса цели.
-- **DATA** — поля сущности/связи; `id` передаётся здесь (`{ id: busyId, … }`).
+- **DATA** — поля сущности/связи; явный `id` — здесь (`{ id, … }`) или шагом `Класс(id)`;
+  у v5-класса явный id запрещён — его считает схема (§ 3.2).
   Валидация **строгая, всегда**: поле вне `Schema.attributes` → `ValidationError`;
   default-ы схемы подставляются; id в `data` не хранится (он — колонка).
-- **Deep-merge при UPDATE**: меняются только указанные листья —
-  `set({ price: { RUB: 1100 } })` сохранит `USD/EUR` и остальные поля.
-  Массивы/скаляры заменяются целиком. `links` домерживаются по ключам.
-- **Концы LINK**: объявленные в `Schema.links` обязательны; значения — id или Row.
+- **Deep-merge при `update`** (и у create-версии по известному id): меняются только
+  указанные листья — `update({ price: { RUB: 1100 } })` сохранит `USD/EUR` и остальные
+  поля. Массивы/скаляры заменяются целиком. `links` домерживаются по ключам.
+- **Концы LINK**: по `Schema.links` v2 (§3.1) — обязательные требуются, союз занимает один ключ, лишние связи — ошибка; значения — id, Row или вложенная цепочка (§6.1).
 - **account/owner NOT NULL**: `.account()/.owner()` → `connect()` → System-аккаунт.
 - Версии монотонны (`GREATEST(clock, prev+1µs)`), коллизия 23505 ретраится.
 - Цепочка переиспользуема: повторный терминал = повторное исполнение плана.
 
-### Связи: контекст и `.link()`
+### 6.1 Связи: путь и слоты `.Класс.set()` / `.Класс.unset()`
+
+Один закон: **владелец создаваемой связки берётся из валидного пути; прочие концы —
+слотами** `.Класс.set(значение)` после глагола записи. Слот — свойство-класс БЕЗ вызова
+(`.Сотрудник.set(x)`, не `.Сотрудник(x)`); валиден только для конца из `Schema.links` и
+требует операцию записи ПЕРЕД собой: `…create(…).Класс.set(x)` / `…update(…).Класс.unset()`;
+слот без глагола — ошибка `link slot needs a write`.
 
 ```ts
-// 1) контекст ДО операции: шаги-связи, затем класс-цель (значение + фильтр целей)
-await db.Сотрудник(s).Окно(w).Запись(b).занятость().set({ id: busyId, kind: 'booking' }).rows()
+// СОЗДАНИЕ: владелец Запись — из пути, предмет и исполнитель — слотами
+await db.Запись(b).позиция().create({ qty: 1, price: { RUB: 1500 } })
+        .Услуга.set(u).Сотрудник.set(s).rows()
 
-// 2) .link(Класс, target) — ТОЛЬКО значение связи, в фильтр целей не входит:
-await db.занятость(busyId).link('Сотрудник', s).link('Окно', w).link('Запись', b)
-        .set({ kind: 'booking' }).rows()
+// занятость: владелец Сотрудник из пути, окно и запись — слотами; id считает схема (§ 3.2)
+await db.Сотрудник(s).занятость().create({ kind: 'booking' }).Окно.set(w).Запись.set(b).rows()
 
-// разница видна на UPDATE: сменить исполнителя ВСЕХ позиций записи —
-await tr.Запись(b).позиция({}).link('Сотрудник', новый).set({}).rows()
-// контекст-шаг Сотрудник(новый) тут не годится: он ФИЛЬТРОВАЛ бы позиции по старой связи
+// ПЕРЕВЕС связи (update): цель ищется путём/pivot, слот пишет новое значение БЕЗ фильтра
+await tr.Запись(b).позиция().Сотрудник(старый).позиция().update().Сотрудник.set(новый).rows()
+
+// СОЮЗ-конец [Услуга|Комплекс]: слот замещает конец целиком (соседний класс снимается)
+await db.позиция(p).update().Комплекс.set(k).rows()      // была Услуга — снята, стал Комплекс
+
+// СНЯТИЕ optional-конца
+await db.занятость(bz).update({ kind: 'hold' }).Запись.unset().rows()
+
+// вложенная цепочка как значение слота — та же транзакция, ровно одна сущность:
+await db.Запись(b).позиция().create({ qty: 1 })
+        .Услуга.set(u)
+        .Сотрудник.set(db.Сотрудник().create({ name: 'Новичок' }).Org.set(org)).rows() // создать И привязать
 ```
 
 ### `.delete({ confirm })` — превью и серверное удаление
@@ -343,14 +453,14 @@ await db.Запись(b).занятость().delete({ confirm: true }).rows() /
 
 Цели = фильтр шага + контекст-связи. Замыкание (цели + все живые зависимые) собирается
 одним CTE; `confirm: true` шлёт один SQL `DELETE` — триггер БД тумбстоунит дерево
-(+advisory-lock). История неприкосновенна; повторный delete → `[]`; `set()` по тому же
+(+advisory-lock). История неприкосновенна; повторный delete → `[]`; `create()` с тем же
 id — воскрешение.
 
 ### Откат плана
 
 ```ts
-await db.Клиент(id).set({ name: 'Новое' })      // валидный сегмент…
-        .Запись().set({ чепуха: 1 })            // …невалидный: ValidationError
+await db.Клиент(id).update({ name: 'Новое' })   // валидный сегмент…
+        .Запись().create({ чепуха: 1 })         // …невалидный: ValidationError
         .rows()
 // ← ОТКАТ ВСЕГО: имя клиента не изменилось, версий не прибавилось
 ```
@@ -360,25 +470,28 @@ await db.Клиент(id).set({ name: 'Новое' })      // валидный
 ## 7. Транзакции
 
 ```ts
+const busyId = uuidv5(`v1.booking:entity:busy:${slotId}:${staffId}`)   // id известен ДО создания (§ 3.2)
+
 const tr = await db.begin()                  // тот же API на выделенном соединении
 await tr.lock('busy', staffId, slotId)       // advisory-xact-lock до конца транзакции
 const занято = await tr.занятость(busyId).first()
-if (!занято) await tr.Сотрудник(s).Окно(w).занятость(busyId).set({ kind: 'booking' }).rows()
+if (!занято) await tr.Сотрудник(s).занятость().create({ kind: 'booking' }).Окно.set(w).rows()
 await db.commit(tr)                          // или db.rollback(tr) / tr.commit() / tr.rollback()
 ```
 
 Повторный commit/rollback — no-op. `lock()` вне транзакции — ошибка. Держите транзакции
-короткими. **Рецепт двойной брони**: `lock(мастер, окно)` + детерминированный id занятости +
-перечитать `first()` под локом → параллельная транзакция видит бронь и отказывает
-(ровно одна успешна — покрыто тестом-гонкой).
+короткими. **Рецепт двойной брони**: id занятости детерминирован схемой (v5 — § 3.2), так
+что дубль невозможен в принципе (второй `create` стал бы версией той же занятости);
+`lock(мастер, окно)` + перечитка `first()` под локом нужны, чтобы сопернику честно
+ОТКАЗАТЬ, а не молча версионировать чужую бронь (ровно одна успешна — покрыто тестом-гонкой).
 
 ---
 
 ## 8. Батчи
 
 ```ts
-db.batch('окна').Расписание(sch).Окно().set({ start, end })   // план встал в очередь
-db.batch('окна').Расписание(sch).Окно().set({ … })
+db.batch('окна').Расписание(sch).Окно().create({ start, end })   // план встал в очередь
+db.batch('окна').Расписание(sch).Окно().create({ … })
 db.batch('окна').size()                        // 2
 const res = await db.batch('окна').run()       // одна транзакция; Row[][] по порядку
 db.batch('окна').discard()                     // отменить
@@ -387,8 +500,9 @@ db.batch('окна').discard()                     // отменить
 - `run()` атомарен: любая ошибка откатывает всё.
 - Операции в батч-цепочке кладут ПЛАН в очередь (многосегментные планы — одним элементом);
   терминал на такой цепочке — ошибка `plan is queued in the batch — call batch.run()`.
-- Подряд идущие чистые INSERT одного класса (один шаг, пустой фильтр, без data.id и `.link`)
-  склеиваются в один multi-VALUES.
+- Подряд идущие чистые `create()` одного класса (план из одного шага, без `data.id` и
+  слотов) склеиваются в один multi-VALUES; **v5-классы — поштучно** (id считается из
+  концов/полей — § 3.2), семантика та же.
 - Read-вызовы на батч-фасаде исполняются сразу, мимо очереди.
 
 ---
@@ -533,7 +647,7 @@ db.acl.reload()                                     // сброс кэша Resou
 ```
 
 **`connect({ account, enforceAcl: true })`** — те же решения в цепочках: каждый шаг —
-`READ`, `set()`/anonymize/батчи — `WRITE`, `delete()` — `DELETE` **по всем классам каскада**
+`READ`, `create()`/`update()`/anonymize/батчи — `WRITE`, `delete()` — `DELETE` **по всем классам каскада**
 (deny в замыкании откатывает транзакцию); `watch()` отдаёт события только безусловных
 allow-классов (payload нечем проверить предикат). Правила фиксируются на connect.
 
@@ -542,10 +656,10 @@ const u = await connect({ dsn, schema, account: user.id, enforceAcl: true })
 await u.Запись().rows()      // [7.6 ms] только owner = user.id — предикат в WHERE заранее
 await u.Запись().count()     // честный count по суженному множеству
 await u.Организация().rows() // Error: letopis: acl denies READ on Org — no matching rule
-const [z] = await u.Запись().set({})            // owner пришпилен правилом → user.id
-await u.Запись().owner(other).set({})           // Error: acl pins Booking writes to owner …
-await u.Запись(чужаяId).set({ status: '…' })    // → [] — цель вне предиката не находится
-// и не перехватывается: «не нашёл среди своих» при существующей чужой НЕ превращается в INSERT
+const [z] = await u.Запись().create().rows()            // owner пришпилен правилом → user.id
+await u.Запись().owner(other).create().rows()           // Error: acl pins Booking writes to owner …
+await u.Запись(чужаяId).update({ status: '…' }).rows()  // → [] — цель вне предиката не находится
+// create по известному чужому id тоже НЕ перехватывает: → [] вместо новой версии
 ```
 
 Оверхед (article-полигон 1.1M, p50 из 20; `bench/acl.bench.mjs`):
@@ -687,7 +801,7 @@ const stop = await db.watch('Запись', onEvent, {
 ```ts
 const db = await connect({ dsn, schema, account: tenantId, enforceAccount: true })
 await db.Запись().rows()                 // ТОЛЬКО строки этого account (фильтр на каждом шаге)
-await db.Клиент().set({ name: 'X' })     // запись пришпилена к account
+await db.Клиент().create({ name: 'X' })  // запись пришпилена к account
 db.Запись().account(чужой).rows()        // ошибка: reads are pinned to account …
 ```
 
@@ -808,7 +922,7 @@ deadlock detected — letopis: transaction is aborted, retry the whole db.begin(
 
 Разделы: [11.1 Модуль](#111-модуль-connect-и-экспорты) · [11.1a up](#111a-upopts) ·
 [11.2 EntityDb](#112-entitydb--корень) · [11.3 Chain: чтение](#113-chain--чтение) ·
-[11.4 Операторы](#114-операторы-фильтров) · [11.5 Запись](#115-запись-set--delete--anonymize) ·
+[11.4 Операторы](#114-операторы-фильтров) · [11.5 Запись](#115-запись-create--update--delete--anonymize) ·
 [11.6 Транзакции](#116-транзакции-entitytx) · [11.7 Батчи](#117-batch) ·
 [11.8 Таблицы](#118-таблицы-accounts--credentials--resources--rules) ·
 [11.9 db.auth](#119-dbauth--вход-и-сессии) · [11.10 db.acl](#1110-dbacl) ·
@@ -932,7 +1046,7 @@ await up({ dsn, schema: 'v1.booking', version: 1 })
 ```ts
 const db = await up({ schema: 'booking', version: 1, dsn })      // [7.4 s] образ+контейнер+схема
 await db.Клиент().count()                                        // → 0 — свежая схема
-const [аня] = await db.Клиент().set({ name: 'Аня', contact: '+7 900' }).rows()
+const [аня] = await db.Клиент().create({ name: 'Аня', contact: '+7 900' }).rows()
 await db.close()
 
 // … docker stop letopis-timescale (ребут, уборка, что угодно) …
@@ -947,6 +1061,7 @@ await db2.close()
 ```ts
 import {
   connect, up, cursorOf, totpCode,                       // функции
+  uuidv5, uuidv7, LETOPIS_NS,                            // генерация id (§ 3.2): формула v5 открыта
   ne, gt, gte, lt, lte, between, inList, like, ilike,    // операторы (18)
   starts, ends, has, hasAny, hasAll, exists, isNull, not, or,
   ValidationError, Registry,                             // классы
@@ -976,7 +1091,7 @@ import type {
 
 **Назначение и алгоритм.** Старт цепочки чтения/записи (§ 4–6). Ничего не выполняет —
 только копит шаги; SQL строится и уходит в БД одним запросом на терминале
-(`rows/execute/count/…` — § 11.3). Формы `filter` нормализуются сразу: объект с `.id`
+(`rows/run/count/…` — § 11.3). Формы `filter` нормализуются сразу: объект с `.id`
 сворачивается в строку-id.
 
 **Примеры**
@@ -1015,8 +1130,8 @@ deadlock/serialization ошибка приходит сразу с подска
 
 ```ts
 const tr = await db.begin()                                   // [0.8 ms]
-await tr.Организация('…0901').Услуга().set({ id: '…0922', name: 'Укладка', duration: 15, price: { RUB: 700 } }).rows()
-// [7.0 ms] → [Row] — видно ТОЛЬКО внутри tr
+await tr.Организация('…0901').Услуга().create({ name: 'Укладка', duration: 15, price: { RUB: 700 } }).rows()
+// [7.0 ms] → [Row] — id вычислен схемой: uuidv5(Org, "Укладка") (§ 3.2); видно ТОЛЬКО внутри tr
 await tr.commit()                                             // [2.7 ms] — теперь видно всем
 ```
 
@@ -1024,10 +1139,10 @@ await tr.commit()                                             // [2.7 ms] — т
 
 ```ts
 const tr = await db.begin()
-await tr.Услуга('…0922').set({ price: { RUB: 9900 } }).rows()
-await tr.Услуга('…0922').first()   // внутри tx → price.RUB = 9900
+await tr.Услуга({ name: 'Укладка' }).update({ price: { RUB: 9900 } }).rows()
+await tr.Услуга({ name: 'Укладка' }).first()   // внутри tx → price.RUB = 9900
 await tr.rollback()                // [0.8 ms]
-await db.Услуга('…0922').first()   // снаружи → price.RUB = 700 — изменение исчезло
+await db.Услуга({ name: 'Укладка' }).first()   // снаружи → price.RUB = 700 — изменение исчезло
 ```
 
 #### `db.commit(tr): Promise<void>` / `db.rollback(tr): Promise<void>`
@@ -1069,8 +1184,8 @@ Tombstone-версия приходит с `deleted: true`.
 
 ```ts
 const stop = await db.watch('Клиент', (e) => пойманные.push(e))   // [34.8 ms]
-await db.Организация('…0901').Клиент().set({ id: '…0932', name: 'Пётр §11' }).rows()
-await db.Клиент('…0932').set({ name: 'Пётр Второй' }).rows()
+await db.Организация('…0901').Клиент().create({ id: '…0932', name: 'Пётр §11' }).rows()
+await db.Клиент('…0932').update({ name: 'Пётр Второй' }).rows()
 await db.Клиент('…0932').delete({ confirm: true }).rows()
 // пойманные (3 события: insert → update → tombstone):
 // { partition: 'entity', class: 'Customer', id: '…0932', updated: '…34.775349+00:00', deleted: false }
@@ -1087,7 +1202,7 @@ const stop = await db.watch('Клиент', (e) => события.push(e), {
 })
 // авария: pg_terminate_backend по LISTEN-соединению …
 // onReconnect сработал через 0.1 s после обрыва (реальный прогон)
-await db.Клиент('…0932').set({ name: 'Пётр после обрыва' }).rows()
+await db.Клиент('…0932').create({ name: 'Пётр после обрыва' }).rows()   // create по id — воскрешение
 // событие после reconnect: { class: 'Customer', id: '…0932', updated: '…35.40884+00:00', deleted: false }
 await stop()
 ```
@@ -1146,8 +1261,8 @@ await db.sql.unsafe('SELECT count(*)::int AS n FROM "v1.article"."Entity"')
 
 **Назначение и алгоритм.** Продолжение пути по связям: прямой переход (`e.id =
 prev.links->>'Класс'`) кладётся точным равенством, обратный — containment
-`links @> {prevClass: prevId}` в кандидаты + перепроверку. В `set()`-цепочке шаги до
-последнего — **контекст** (§ 11.5).
+`links @> {prevClass: prevId}` в кандидаты + перепроверку. В цепочке записи шаги до
+операции — **контекст** (§ 11.5).
 
 **Примеры**
 
@@ -1240,7 +1355,7 @@ await db.Сотрудник().ids()   // [3.8 ms] → 302 id
 Параметров нет.
 
 **Назначение и алгоритм.** `SELECT count(*)` поверх соединения шагов — считает **пути**
-(как `execute()`), не уникальные сущности: для цепочки из одного класса это одно и то же,
+(как `run()`), не уникальные сущности: для цепочки из одного класса это одно и то же,
 для многошаговой — нет (см. кейс `.rows()`).
 
 ```ts
@@ -1479,7 +1594,7 @@ await db.Запись().countBy('data.status')   // [575.8 ms] — 250k сущн
 
 | Параметр | Тип | Описание |
 |---|---|---|
-| `name` | `string` | ключ ТЕКУЩЕГО шага в объектах-путях `execute()` |
+| `name` | `string` | ключ ТЕКУЩЕГО шага в объектах-путях `run()` |
 
 **Назначение.** Переименование ключа шага в выводе (данные и SQL не меняются) — удобно,
 когда один класс встречается в пути дважды.
@@ -1495,7 +1610,7 @@ await db.Организация(org).alias('салон').Сотрудник({ na
 
 | Параметр | Тип | Описание |
 |---|---|---|
-| `v` | `string \| string[] \| has/hasAny/hasAll` | чтение: фильтр колонки `tags` (строка ≡ содержит; массив ≡ содержит все); в `set()`-цепочке — **значение** тегов INSERT |
+| `v` | `string \| string[] \| has/hasAny/hasAll` | чтение: фильтр колонки `tags` (строка ≡ содержит; массив ≡ содержит все); в цепочке записи — **значение** тегов `create()`-INSERT |
 
 **Назначение и алгоритм.** Фильтр по массивной колонке `tags` (`@>` — GIN-индекс,
 кандидаты + перепроверка). В записи — модификатор значения.
@@ -1512,7 +1627,7 @@ await db.Клиент().tags(hasAny(['vip', 'telegram'])).count()  // [3.5 ms]
 
 | Параметр | Тип | Описание |
 |---|---|---|
-| `v` | `uuid \| { id }` | чтение: фильтр колонки `account`/`owner`; в `set()`-INSERT — значение колонки |
+| `v` | `uuid \| { id }` | чтение: фильтр колонки `account`/`owner`; при `create()` — значение колонки |
 
 **Назначение и алгоритм.** Прямое равенство по uuid-колонке (btree). Под `enforceAccount`
 чужой `.account()` — ошибка; под `enforceAcl` конфликт с пришпиленной правилом колонкой —
@@ -1670,119 +1785,145 @@ await db.Услуга(or({ name: 'Стрижка' }, { duration: lt(45) })).coun
 
 **Кейс:** «стрижка или что-нибудь быстрое» — один запрос: 1 (Стрижка) + 101 (быстрые) = 102.
 
-### 11.5 Запись: set / delete / anonymize
+### 11.5 Запись: create / update / delete / anonymize
 
 Операции — **звенья плана** (§ 6): каждая применяется к шагу, к которому приклеена точкой,
 и возвращает цепочку. Исполняет **терминал** — весь план одной транзакцией (внутренней,
 с ретраем transient; внутри `db.begin()` — транзакцией пользователя); отказ любого сегмента
-откатывает всё. Продолжение цепочки — от результата операции.
+откатывает всё. Продолжение цепочки — от результата операции. Старый `set()` разбит на
+`create()`/`update()` в 0.16.0 — бросает подсказку.
 
-#### `.set(data?): Chain`
+#### `.create(data?): Chain`
 
 | Параметр | Тип | Описание |
 |---|---|---|
-| `data` | `Record<string, unknown>?` | поля по `Schema.attributes` (строгая валидация: лишний ключ — ошибка) + опциональный `id` — явный id строки |
-
-Роль фильтра шага операции:
-
-| Форма | Пример | Смысл |
-|---|---|---|
-| — | `db.Услуга().set({…})` | **INSERT** новой сущности |
-| `{}` пустой объект | `db.позиция({}).set({…})` | **UPDATE всех** в границах контекста |
-| `string` / `Row` | `db.Услуга('id').set({…})` | **UPSERT** по id: есть — новая версия, нет — INSERT с этим id |
-| объект | `db.Запись({ status: 'created' }).set({…})` | UPDATE каждого найденного (в контексте) |
-
-**Назначение и алгоритм.** Единственный способ записи. На терминале для каждого сегмента:
-(1) под `enforceAcl` — WRITE-решение по классу (deny — откат; предикат правила пришпиливает
-`owner`/`account` и фильтрует цели); (2) контекст-шаги резолвятся в связи — каждый обязан
-дать **ровно одну** сущность; (3) поиск целей: INSERT-форма не ищет, id/фильтр — ищут в
-границах контекста; (4) на каждую цель: **deep-merge** листьев `data`, слияние links
-(контекст + `.link()`), строгая валидация, **один INSERT новой версии** с
-`updated = GREATEST(clock_timestamp(), prev + 1 µs)`; (5) UPSERT по id при пустом поиске —
-INSERT (воскрешает удалённую; под ACL существующая-но-недоступная **не перехватывается**);
-(6) конфликт `23505`/transient ретраится транзакцией плана. Сегмент после операции
-исполняется **для каждой строки её результата** (fan-out); `set` сразу после `set` — новая
-версия тех же сущностей (self).
+| `data` | `Record<string, unknown>?` | поля по `Schema.attributes` (строгая валидация: лишний ключ — ошибка) + опциональный `id` (у v5-класса запрещён — id считает схема, § 3.2) |
+
+**Назначение и алгоритм.** «Чтобы сущность существовала». На терминале: (1) под
+`enforceAcl` — WRITE-решение по классу (deny — откат; предикат правила пришпиливает
+`owner`/`account`); (2) владелец создаваемой связки — из валидного пути (каждый
+контекст-шаг обязан дать **ровно одну** сущность), прочие концы — слотами; (3) id: явный
+(шаг `Класс(id)` или `data.id`) либо по правилу схемы — v4/v7 генерируются, v5 вычисляется
+из концов/полей (§ 3.2); (4) id известен и **уже существует** (в границах пути) → **новая
+версия** с deep-merge — идемпотентный create, REST-PUT семантика (удалённую — воскрешает;
+под ACL существующая-но-недоступная **не перехватывается** → `[]`); не существует → **один
+INSERT** с `updated = GREATEST(clock_timestamp(), prev + 1 µs)`; (5) конфликт
+`23505`/transient ретраится транзакцией плана. Фильтр-объект перед create — ошибка
+ПОСТРОЕНИЯ (`create() takes no filter`); create на pivot-шаге — ошибка.
 
 **Примеры**
 
 ```ts
-await db.Организация().set({ name: 'Пилигрим' }).rows()   // [9.0 ms] INSERT + defaults из Schema
+await db.Организация().create({ name: 'Пилигрим' }).rows()   // [9.0 ms] INSERT + defaults из Schema
 // → [{ id: '39aba8a5-…', class: 'Org', data: { name: 'Пилигрим', active: true, timezone: 'Europe/Moscow' }, … }]
 
-await db.Организация().set({ id: '…0901', name: 'Демо-салон §11' }).rows()   // [7.0 ms] INSERT с явным id
+await db.Организация().create({ id: '…0901', name: 'Демо-салон §11' }).rows()
+// [7.0 ms] явный id — можно: Org наследует v7 (§ 3.2); повторный create того же id → новая версия
 
-await db.Организация('…0901').Сотрудник().set({ id: '…0911', name: 'Мия', roles: ['master'] }).rows()
+await db.Организация('…0901').Сотрудник().create({ id: '…0911', name: 'Мия', roles: ['master'] }).rows()
 // [14.5 ms] контекст → links: { Org: '…0901' }
 
-await db.Услуга('…0921').set({ price: { RUB: 1400, USD: 15 } }).rows()   // [7.0 ms] UPSERT: новая версия
+await db.Организация('…0901').Услуга().create({ name: 'Укладка экспресс', duration: 15, price: { RUB: 700 } }).rows()
+// [7.2 ms] Услуга — v5-класс: id вычислен схемой из (Org, name) — § 3.2;
+// повторный create той же пары (салон, имя) → новая ВЕРСИЯ той же услуги, не дубль
+
+db.Услуга({ name: 'Укладка экспресс' }).create({ duration: 20 })   // [0.1 ms] — синхронно, до БД:
+// Error: letopis: create() takes no filter — Услуга(id).create(…) fixes the id, searching is update()
+
+await db.Услуга().create({ name: 'X', чепуха: 1 }).rows()   // [1.4 ms] — ошибка НА ТЕРМИНАЛЕ:
+// ValidationError: letopis: validation failed for "Service":
+//   duration — The 'duration' field is required.; … forbidden keys: 'чепуха'
+
+db.Услуга('…0921').Клиент()   // [0.1 ms] недопустимый переход — синхронно при построении
+// Error: letopis: no path Service → Customer
+```
+
+#### `.update(data?): Chain`
+
+| Параметр | Тип | Описание |
+|---|---|---|
+| `data` | `Record<string, unknown>?` | поля по `Schema.attributes` (строгая валидация); без аргумента — версия без изменения полей (например, ради слотов) |
+
+**Назначение и алгоритм.** Новая версия **каждого** найденного путём. Цели ищутся как при
+чтении — id, фильтр, pivot; `Класс()` ≡ `Класс({})` — «все в границах контекста». На каждую
+цель: **deep-merge** листьев `data` (`update({ price: { RUB: 1100 } })` сохранит `USD` и
+остальные поля; массивы/скаляры — целиком), слияние links (слоты `.Класс.set()`/`.unset()`),
+строгая валидация, один INSERT новой версии. Не найдено → `[]` — update **НИКОГДА не
+создаёт**. Сегмент после операции исполняется **для каждой строки её результата** (fan-out);
+`update` сразу после `update` — новая версия тех же сущностей (self).
+
+**Примеры**
+
+```ts
+await db.Услуга('…0921').update({ price: { RUB: 1400, USD: 15 } }).rows()   // [7.0 ms] новая версия по id
 // было:  { name: 'Массаж головы', price: { RUB: 1200 }, duration: 30, description: 'релакс', … }
 // стало: { name: 'Массаж головы', price: { RUB: 1400, USD: 15 }, duration: 30, description: 'релакс', … }
 // deep-merge тронул только листья price; duration/description целы
 
-await db.Клиент('…0931').Запись({ status: 'created' }).set({ status: 'confirmed' }).rows()   // [12.1 ms]
+await db.Клиент('…0931').Запись({ status: 'created' }).update({ status: 'confirmed' }).rows()   // [12.1 ms]
 // → [{ id: '…0962', status: 'confirmed' }, { id: '…0963', status: 'confirmed' }] — только записи Златы
 
-await db.Клиент('…0931').Запись({}).set({ status: 'completed' }).rows()   // [10.7 ms] ВСЕ в контексте
+await db.Клиент('…0931').Запись().update({ status: 'completed' }).rows()   // [10.7 ms] ВСЕ в контексте
 // → [{ id: '…0962', status: 'completed' }, { id: '…0963', status: 'completed' }]
 
-await db.Услуга().set({ name: 'X', чепуха: 1 }).rows()   // [1.4 ms] — ошибка НА ТЕРМИНАЛЕ:
-// ValidationError: letopis: validation failed for "Service":
-//   duration — The 'duration' field is required.; … forbidden keys: 'чепуха'
-
-db.Услуга('…0921').set({ duration: 30 }).link('Сотрудник', м)   // [0.1 ms]
-// Error: letopis: step modifier after set() — add a class step first
+await db.Запись({ status: 'нет-такого' }).update({ status: 'x' }).rows()   // → [] — НИЧЕГО не создано
 ```
 
 **Кейс: план из нескольких операций — реальный прогон**
 
 ```ts
 // обновить клиента → вставить ему запись (продолжение от записанного, одна транзакция)
-await db.Клиент('…0931').set({ language: 'en' })
-        .Запись().set({ id: '…0964', status: 'created', total: { RUB: 990 } })
+await db.Клиент('…0931').update({ language: 'en' })
+        .Запись().create({ id: '…0964', status: 'created', total: { RUB: 990 } })
         .rows()   // [15.5 ms]
 // → [{ id: '…0964', class: 'Booking', links: { Customer: '…0931' }, status: 'created' }]
 
-// self-set: две версии подряд
-await db.Запись('…0964').set({ status: 'confirmed' }).set({ status: 'completed' }).rows()   // [13.6 ms]
+// self-update: две версии подряд
+await db.Запись('…0964').update({ status: 'confirmed' }).update({ status: 'completed' }).rows()   // [13.6 ms]
 // → ['completed']; versions: ['created', 'confirmed', 'completed']
 
 // хвост-чтение после операции — в той же транзакции
-await db.Клиент('…0931').set({ language: 'ru' }).Запись().count()   // [201.6 ms] → 7
+await db.Клиент('…0931').update({ language: 'ru' }).Запись().count()   // [201.6 ms] → 7
 
 // ОТКАТ: невалидный второй сегмент откатывает и первый
-await db.Клиент('…0931').set({ name: 'Не запишется' }).Запись().set({ чепуха: 1 }).rows()
+await db.Клиент('…0931').update({ name: 'Не запишется' }).Запись().create({ чепуха: 1 }).rows()
 // Error: letopis: validation failed for "Booking" …   [6.1 ms]; имя клиента не изменилось
 
 // fan-out: обновить клиента → снести ВСЕ его записи
-await db.Клиент('…0931').set({ active: true }).Запись().delete({ confirm: true }).rows()
+await db.Клиент('…0931').update({ active: true }).Запись().delete({ confirm: true }).rows()
 // [229.4 ms] → 7 записей, все с $deleted: true
 ```
 
-#### `.link(className, target): Chain`
+#### Слоты связей: `.Класс.set(target): Chain` / `.Класс.unset(): Chain`
 
-| Параметр | Тип | Описание |
-|---|---|---|
-| `className` | `string` | класс связи (id или алиас) |
-| `target` | `string \| { id }` | конец связи |
+| Форма | Описание |
+|---|---|
+| `.Класс.set(target)` | значение конца связи новой версии; `target` = id \| Row \| вложенная цепочка |
+| `.Класс.unset()` | снять optional-конец (0.16.0: переименован из `.Класс.delete()` — старое имя бросает подсказку) |
 
-**Назначение и алгоритм.** Значение связи для записи **БЕЗ участия в фильтре целей** —
-в отличие от контекст-шага, который и фильтрует, и пишет. Кладётся в links новой версии
-(поверх контекста). Только до операции; после — ошибка `step modifier after set()`.
+**Назначение и алгоритм.** Слот — свойство-класс БЕЗ вызова, идёт ПОСЛЕ глагола записи
+(`create`/`update`); слот без операции — ошибка `link slot needs a write`. Пишет конец в
+links **БЕЗ участия в фильтре целей** (в отличие от шага пути, который фильтрует). Валиден
+только для конца из `Schema.links` владельца; союз-конец `[A|B]` замещается целиком
+(соседний класс снимается); дубль одного слота — ошибка. `target`-цепочка
+исполняется в той же транзакции и обязана дать ровно одну сущность класса конца.
 
 **Примеры**
 
 ```ts
-await db.навык().link('Сотрудник', м9).link('Услуга', у9).set({}).rows()   // [4.1 ms] ОДИН INSERT
+await db.Сотрудник(м9).навык().create().Услуга.set(у9).rows()   // [4.1 ms] ОДИН INSERT
 // → { id: '7b374ae4-…', class: 'skill', links: { Staff: '…0911', Service: '…0921' } }
+// навык — v5: id вычислен из (Staff, Service|Complex) — второй раз тот же навык не завести
+
+// вложенная цепочка — создать И привязать в одной транзакции:
+await db.Запись(b).позиция().create({ qty: 1 }).Услуга.set(db.Услуга(у).update({ active: true })).rows()
 ```
 
 **Кейс: перевесить исполнителя на всех позициях записи**
 
 ```ts
-await tr.Запись(b).позиция({}).link('Сотрудник', новый).set({}).rows()
-// контекст-шаг Сотрудник(новый) тут НЕ годится: он фильтровал бы позиции по старой связи —
-// а .link только записывает значение
+await tr.Запись(b).позиция().update().Сотрудник.set(новый).rows()
+// цель ищется путём (все позиции записи); слот пишет нового исполнителя БЕЗ фильтра по старому
 ```
 
 #### `.delete(opts?): Chain`
@@ -1797,14 +1938,14 @@ await tr.Запись(b).позиция({}).link('Сотрудник', новы
 под `enforceAcl` DELETE-решение проверяется на класс целей **и каждый класс замыкания**
 (deny откатывает план); `DELETE` по целям будит серверный триггер: advisory-lock →
 tombstone-версия → рекурсивное удаление зависимых. Возврат — замыкание с `$deleted: true`.
-История остаётся; `set()` по тому же id — воскрешение. Продолжение цепочки — от строк
+История остаётся; `create()` с тем же id — воскрешение. Продолжение цепочки — от строк
 класса цели.
 
 **Примеры**
 
 ```ts
 await db.Запись('…0961').delete().rows()   // [192.7 ms] ПРЕВЬЮ — кандидаты живы:
-// → [{ id: '…0961', class: 'Booking' }, { id: 'busy-0961', class: 'busy' }, { id: '20790dc3-…', class: 'item' }]
+// → [{ id: '…0961', class: 'Booking' }, { class: 'busy', … }, { class: 'item', … }] — бронь + занятость + позиция
 // запись жива: true
 
 await db.Запись('…0961').delete({ confirm: true }).rows()   // [209.2 ms] — сервер нашёл зависимых:
@@ -1819,8 +1960,8 @@ const последствия = await db.Запись(bid).delete().rows()
 if (операторПодтвердил) {
   await db.Запись(bid).delete({ confirm: true }).rows()        // [209.2 ms] бронь + занятость + позиция
 }
-// клиент передумал: воскрешение тем же id (зависимые пересоздать явно)
-await db.Клиент('…0931').Запись('…0961').set({ status: 'created', total: { RUB: 500 } }).rows()  // [11.3 ms]
+// клиент передумал: воскрешение тем же id — create (зависимые пересоздать явно)
+await db.Клиент('…0931').Запись('…0961').create({ status: 'created', total: { RUB: 500 } }).rows()  // [11.3 ms]
 ```
 
 #### `.anonymize(fields): Chain`
@@ -1867,10 +2008,10 @@ await db.Клиент().tags('anonymized').count()                        // в
 
 ```ts
 const tr = await db.begin()                    // [0.8 ms]
-await tr.Услуга('…0922').set({ price: { RUB: 9900 } }).rows()
-await tr.Услуга('…0922').first()               // внутри → 9900
+await tr.Услуга({ name: 'Укладка' }).update({ price: { RUB: 9900 } }).rows()
+await tr.Услуга({ name: 'Укладка' }).first()   // внутри → 9900
 await tr.rollback()                            // [0.8 ms]
-await db.Услуга('…0922').first()               // снаружи → 700, изменения нет
+await db.Услуга({ name: 'Укладка' }).first()   // снаружи → 700, изменения нет
 ```
 
 **Кейс: commit** — § 11.2 `db.begin()`; ниже — главный сценарий `lock`.
@@ -1899,20 +2040,24 @@ await db.lock('x')
 **Кейс: гонка двойной брони — реальный прогон двух транзакций**
 
 ```ts
-// два администратора жмут «забронировать» на одно окно одновременно
+// два администратора жмут «забронировать» на одно окно одновременно;
+// id занятости детерминирован (v5, § 3.2) — известен ДО создания:
+const busyId = uuidv5(`v1.article:entity:busy:${окно.id}:${мастер.id}`)
 const trA = await db.begin(), trB = await db.begin()
-await trA.lock('busy', '…0911', '…0951')            // [1.4 ms] A первый
+await trA.lock('busy', мастер.id, окно.id)          // [1.4 ms] A первый
 const гонкаB = (async () => {
-  await trB.lock('busy', '…0911', '…0951')          // B ВИСИТ до конца trA
+  await trB.lock('busy', мастер.id, окно.id)        // B ВИСИТ до конца trA
   const занято = await trB.занятость(busyId).first() // перечитка под локом
   if (занято) { await trB.rollback(); return 'ОТКАЗ: окно уже занято' }
-  await trB.Сотрудник('…0911').Окно('…0951').занятость(busyId).set({ kind: 'booking' }).rows()
+  await trB.Сотрудник(мастер).занятость().create({ kind: 'booking' }).Окно.set(окно).rows()
   await trB.commit(); return 'бронь моя'
 })()
 await trA.занятость(busyId).first()                  // → null — свободно
-await trA.Сотрудник('…0911').Окно('…0951').занятость(busyId).set({ kind: 'booking' }).rows()
+await trA.Сотрудник(мастер).занятость().create({ kind: 'booking' }).Окно.set(окно).rows()
 await trA.commit()
 await гонкаB   // → 'ОТКАЗ: окно уже занято' — B увидел бронь A, дубля нет
+// дубль невозможен и без лока (оба create вычислят ОДИН id — второй стал бы версией);
+// лок нужен, чтобы B получил честный отказ, а не молча версионировал чужую бронь
 
 // а если два лока взять в разном порядке — деадлок, жертва получает:
 // Error: deadlock detected — letopis: transaction is aborted, retry the whole db.begin() block
@@ -1940,26 +2085,28 @@ const b = db.batch('слоты-августа')   // [16 µs]
 
 **Назначение и алгоритм.** Вся очередь — **одна транзакция** (бывший `execute()`);
 результаты по порядку планов (`Row[]` на план; у многосегментного — результат последнего
-сегмента). Подряд идущие «чистые INSERT» одного класса (один шаг, без фильтра, без data.id
-и `.link`) склеиваются в **один multi-VALUES INSERT**; под `enforceAcl` WRITE-проверка и
-пришпиливание — на каждый элемент склейки. Transient-ошибка ретраит всю транзакцию целиком.
-Очередь очищается.
+сегмента). Подряд идущие чистые `create()` одного класса (план из одного шага, без `data.id`
+и слотов; id класса не v5 — § 3.2) склеиваются в **один multi-VALUES INSERT**; под
+`enforceAcl` WRITE-проверка и пришпиливание — на каждый элемент склейки. Transient-ошибка
+ретраит всю транзакцию целиком. Очередь очищается.
 
 **Примеры**
 
 ```ts
 const b = db.batch('слоты-августа')
-b.Окно().set({ id: '…0952', start: '2026-08-01T11:00:00Z', end: '…12:00Z' })
-b.Окно().set({ id: '…0953', start: '2026-08-01T12:00:00Z', end: '…13:00Z' })
-b.Окно().set({ id: '…0954', start: '2026-08-01T13:00:00Z', end: '…14:00Z' })
+b.Расписание(sch).Окно().create({ start: '2026-08-01T11:00:00Z', end: '…12:00Z' })
+b.Расписание(sch).Окно().create({ start: '2026-08-01T12:00:00Z', end: '…13:00Z' })
+b.Расписание(sch).Окно().create({ start: '2026-08-01T13:00:00Z', end: '…14:00Z' })
 b.size()             // [29 µs] → 3
-await b.run()        // [32.1 ms] — 3 INSERT склеены в один multi-VALUES
-// → [[{ id: '…0952', start: '2026-08-01T11:00:00.000Z' }], [{ id: '…0953', … }], [{ id: '…0954', … }]]
+await b.run()        // [32.1 ms] — одна транзакция; Окно — v5-класс → 3 честных INSERT, не склейка
+// → [[{ start: '2026-08-01T11:00:00.000Z', … }], [{ …12:00 }], [{ …13:00 }]]
+//   id каждого окна вычислен схемой: uuidv5(Schedule, start) — § 3.2
 b.size()             // → 0
 ```
 
-**Кейс: генерация расписания на день** — 3 окна одной транзакцией и одним INSERT (выше);
-упавшая валидация любого окна откатывает все. Терминал на плане в батче:
+**Кейс: генерация расписания на день** — 3 окна одной транзакцией (выше); упавшая
+валидация любого окна откатывает все; v7-классы без `data.id` и слотов склеились бы в
+один multi-VALUES INSERT. Терминал на плане в батче:
 `план.rows()` → `Error: letopis: plan is queued in the batch — call batch.run()`.
 
 #### `batch.discard(): void` / `batch.size(): number`
@@ -1968,14 +2115,14 @@ b.size()             // → 0
 
 ```ts
 const b2 = db.batch('отмена')
-b2.Окно().set({ id: '…0955', start: '…', end: '…' })
+b2.Расписание(sch).Окно().create({ start: '2026-08-02T11:00:00Z', end: '…12:00Z' })
 b2.discard()                      // [53 µs]
 b2.size()                         // → 0
-await db.Окно('…0955').first()   // → null — ничего не исполнилось
+await db.Расписание(sch).Окно({ start: '2026-08-02T11:00:00Z' }).first()   // → null — не исполнилось
 ```
 
 **Кейс: черновик импорта** — копим операции по мере парсинга файла; ошибка парсера →
-`discard()`, полный успех → `execute()`.
+`discard()`, полный успех → `run()`.
 
 ### 11.8 Таблицы: accounts / credentials / resources / rules
 
@@ -2621,11 +2768,11 @@ await uc.Запись().count()   // [20.3 ms] → 3 — честный count п
 await uc.Услуга().count()   // [15.9 ms] → 404 — безусловный allow, класс целиком
 await uc.Организация().rows()
 // Error: letopis: acl denies READ on Org — no matching rule (deny by default)   [0.3 ms]
-const [z] = await uc.Запись().set({ status: 'created', total: { RUB: 300 } }).rows()   // [11.7 ms]
+const [z] = await uc.Запись().create({ status: 'created', total: { RUB: 300 } }).rows()   // [11.7 ms]
 z.owner === acc.id   // → true — owner пришпилен правилом
-await uc.Запись().owner(SYS).set({ … }).rows()
+await uc.Запись().owner(SYS).create({ … }).rows()
 // Error: letopis: acl pins Booking writes to owner … — на терминале   [1.8 ms]
-await uc.Запись(чужаяId).set({ status: 'hacked' }).rows()   // [10.9 ms] → [] — чужая жива и НЕ перехвачена
+await uc.Запись(чужаяId).update({ status: 'hacked' }).rows()   // [10.9 ms] → [] — чужая жива и НЕ перехвачена
 await uc.Запись('…0965').delete({ confirm: true }).rows()   // [27.7 ms] → [{ id: '…0965', $deleted: true }]
 // watch: события только безусловных allow-классов —
 // uc.watch(cb) поймал ['Service']; Booking скрыт (предикат не проверить по payload)
@@ -2690,13 +2837,13 @@ db.registry.all.length        // → 15
 | `message` | `string` | `letopis: validation failed for "<Класс>": …` |
 | `issues` | `{ field, type, message, … }[]` | отчёт fastest-validator по каждому полю |
 
-**Назначение.** Бросается из ТЕРМИНАЛА плана (`.set()`/`.anonymize()`/батчи), когда `data`
-не проходит строгую схему класса (недостающее обязательное, лишний ключ, неверный тип) —
-весь план откатывается. Другие ошибки записи (abstract-класс, недостающий конец LINK) —
-обычный `Error` там же.
+**Назначение.** Бросается из ТЕРМИНАЛА плана (`.create()`/`.update()`/`.anonymize()`/батчи),
+когда `data` не проходит строгую схему класса (недостающее обязательное, лишний ключ,
+неверный тип) — весь план откатывается. Другие ошибки записи (abstract-класс, недостающий
+конец LINK) — обычный `Error` там же.
 
 ```ts
-try { await db.Услуга().set({ name: 'X', чепуха: 1 }).rows() }   // [1.4 ms]
+try { await db.Услуга().create({ name: 'X', чепуха: 1 }).rows() }   // [1.4 ms]
 catch (e) {
   e instanceof ValidationError   // → true
   e.issues
@@ -2744,13 +2891,24 @@ AclDecision = { allow, rule?, filter?, code?, message? }         // filter —
 | `unknown class "X". Known: …` | класс вне Schema (со списком) |
 | `ValidationError` (`.issues`) | строгая валидация: мусор или лишние поля |
 | `class "X" is abstract` | запись в abstract |
-| `link "X" requires end "Y"` / `polymorphic end(s)` | не хватает концов LINK |
-| `context step "X" must resolve to exactly one entity` | контекст-шаг дал 0 или >1 |
-| `context step "X" needs an id or a unique filter` | контекст-шаг без фильтра |
-| `step modifier after set()` | модификатор шага (alias/tags/link/…) сразу после операции |
+| `link "X" requires end "Y|Z"` / `has stray link(s)` | не хватает обязательного конца LINK / связь вне объявленных концов (v2); legacy: `polymorphic end(s)` |
+| `context step "X" must resolve to exactly one entity` | шаг-владелец пути дал 0 или >1 |
+| `create() takes no filter — searching is update()` | фильтр-объект перед `create()` (синхронно, при построении) |
+| `create() on a pivot step` | pivot возвращает к существующему узлу — это `update()` |
+| `class "X" computes id (uuid v5 from …)` | явный id у v5-класса (§ 3.2) — id всегда считает схема |
+| `id (uuid v5) of "X" needs end "A\|B"` / `needs scalar data field "f"` | v5-классу не хватает конца (путь/слот) или скалярного поля из `from` |
+| `step modifier after create()/update()` | модификатор шага (alias/tags/…) сразу после операции |
+| `"X" is not a link end of "Y"` | слот `.X.set()` — не конец Y по Schema.links |
+| `slot "X" needs an owner step` | слот на корне (`db.X.set()`) без шага-владельца |
+| `link slot "X" needs a write` | слот без глагола записи — добавить `.create(…)`/`.update(…)` перед ним |
+| `link end "X" of "Y" is required — cannot unset` | `.unset()` обязательного конца |
+| `duplicate link slot "X"` | один конец задан слотом дважды в одной записи |
+| `set() split into create()/update() (0.16.0)` | старый глагол записи — create() вставляет, update() версионирует найденное |
+| `slot .delete() renamed to .unset() (0.16.0)` | старое имя слот-снятия |
+| `.link() removed (0.15.0)` | снесённый `.link()` — теперь слот `.Класс.set()` |
 | `execute() renamed to run() (0.11.0)` | старое имя терминала путей (и `batch.execute()`) |
 | `plan is queued in the batch — call batch.run()` | терминал на батч-цепочке с операциями |
-| `no path X → Y` / `LINK → LINK …` | недопустимый переход чтения |
+| `no path X → Y` / `LINK → LINK …` | недопустимый переход (синхронно при построении цепочки) |
 | `Entity.account is NOT NULL…` | нет account и System-аккаунта |
 | `violates foreign key constraint "entity_*_fk"` | несуществующий класс/аккаунт; удаление класса с данными |
 | `lock() works only inside db.begin()` | лок вне транзакции |
@@ -2778,7 +2936,7 @@ AclDecision = { allow, rule?, filter?, code?, message? }         // filter —
 | `rows()` весь класс, sort+limit 100 | 63 ms | 74 ms |
 | цепочка 3 хопа (пути) | 15 ms | 23 ms |
 | `count()` путей | 15 ms | 20 ms |
-| `set()` новой версии | 8 ms | 12 ms |
+| запись новой версии (`create`/`update`) | 8 ms | 12 ms |
 
 TOAST-порог (data > 2KB): 0 строк. Слабое место — выборка «весь класс с сортировкой»
 (DISTINCT ON всех сущностей класса); лечится селективным фильтром или курсором.
@@ -2792,7 +2950,7 @@ API Reference (§ 11) — `npx tsx bench/api-reference-demo.mjs` (живой art
 - Начинайте цепочку с самого селективного шага.
 - `count()` — пути; количество сущностей дешевле `ids().length`.
 - Каскадное удаление — серверное: один DELETE на всё дерево.
-- Один сегмент плана пишет одним INSERT на цель независимо от числа связей (`.link()`/контекст).
+- Один сегмент плана пишет одним INSERT на цель независимо от числа связей (путь + слоты).
 - EXPLAIN-паттерн — тест `EXPLAIN` (индексы обязаны быть в плане; ноль seq scan).
 
 ---
@@ -2803,30 +2961,31 @@ API Reference (§ 11) — `npx tsx bench/api-reference-demo.mjs` (живой art
 
 ```ts
 // штат и каталог — связи контекст-шагами; терминал .rows() исполняет план
-const [org]  = await db.Организация().set({ name: 'BarberPro' }).rows()
-const [ivan] = await db.Организация(org).Сотрудник().set({ name: 'Иван', roles: ['owner','master'] }).rows()
-const [oleg] = await db.Организация(org).Сотрудник().set({ name: 'Олег', roles: ['master'] }).rows()
-const [стрижка]  = await db.Организация(org).Услуга().set({ name: 'Стрижка', duration: 60, price: { RUB: 1500 } }).rows()
-const [комплекс] = await db.Организация(org).Комплекс().set({ name: 'Стрижка+борода', duration: 90, price: { RUB: 2500 } }).rows()
-await db.Комплекс(комплекс).Услуга(стрижка).позиция().set({ qty: 1 }).rows()   // состав
-await db.Сотрудник(ivan).Комплекс(комплекс).навык().set({}).rows()             // умение
+const [org]  = await db.Организация().create({ name: 'BarberPro' }).rows()
+const [ivan] = await db.Организация(org).Сотрудник().create({ name: 'Иван', roles: ['owner','master'] }).rows()
+const [oleg] = await db.Организация(org).Сотрудник().create({ name: 'Олег', roles: ['master'] }).rows()
+const [стрижка]  = await db.Организация(org).Услуга().create({ name: 'Стрижка', duration: 60, price: { RUB: 1500 } }).rows()
+const [комплекс] = await db.Организация(org).Комплекс().create({ name: 'Стрижка+борода', duration: 90, price: { RUB: 2500 } }).rows()
+// id услуги/комплекса вычислила схема: uuidv5(Org, name) — дубль имени в салоне невозможен (§ 3.2)
+await db.Комплекс(комплекс).состав().create({ qty: 1 }).Услуга.set(стрижка).rows()   // состав комплекса
+await db.Сотрудник(ivan).навык().create().Комплекс.set(комплекс).rows()              // умение
 
 // календарь: период → окна батчем → ростер → исключение
-const [sch] = await db.Организация(org).Расписание().set({ start: '2026-07-10T10:00:00+03:00', end: '…13:00' }).rows()
-db.batch('о').Расписание(sch).Окно().set({ start: '…10:00', end: '…11:00' })   // ×3 — планы в очередь
+const [sch] = await db.Организация(org).Расписание().create({ start: '2026-07-10T10:00:00+03:00', end: '…13:00' }).rows()
+db.batch('о').Расписание(sch).Окно().create({ start: '…10:00', end: '…11:00' })   // ×3 — планы в очередь
 const [[w1],[w2],[w3]] = await db.batch('о').run()
-await db.Расписание(sch).Сотрудник(ivan).смена().set({}).rows()
-await db.Сотрудник(oleg).Окно(w3).занятость().set({ id: `off-${oleg.id}-${w3.id}`, kind: 'off' }).rows()
+await db.Расписание(sch).смена().create().Сотрудник.set(ivan).rows()
+await db.Сотрудник(oleg).занятость().create({ kind: 'off' }).Окно.set(w3).rows()   // id = uuidv5(w3, oleg)
 
-// бронь мульти-слот (90м > 60м → два окна): контекст-форма и .link-форма
-const [bkg] = await db.Клиент(пётр).Запись().set({ status: 'created', total: { RUB: 2500 } }).rows()
-await db.Запись(bkg).Комплекс(комплекс).Сотрудник(ivan).позиция().set({ qty: 1, price: { RUB: 2500 } }).rows()
-await db.занятость().link('Сотрудник', ivan).link('Окно', w2).link('Запись', bkg)
-        .set({ id: `busy-${ivan.id}-${w2.id}`, kind: 'booking' }).rows()
-await db.Сотрудник(ivan).Окно(w3).Запись(bkg).занятость(`busy-${ivan.id}-${w3.id}`).set({ kind: 'booking' }).rows()
+// бронь мульти-слот (90м > 60м → два окна): владелец из пути, концы слотами
+const [bkg] = await db.Клиент(пётр).Запись().create({ status: 'created', total: { RUB: 2500 } }).rows()
+await db.Запись(bkg).позиция().create({ qty: 1, price: { RUB: 2500 } }).Комплекс.set(комплекс).Сотрудник.set(ivan).rows()
+await db.Сотрудник(ivan).занятость().create({ kind: 'booking' }).Окно.set(w2).Запись.set(bkg).rows()
+await db.Сотрудник(ivan).занятость().create({ kind: 'booking' }).Окно.set(w3).Запись.set(bkg).rows()
+// id занятостей детерминированы — uuidv5(окно, мастер): двойная бронь мертва на уровне схемы
 
 // жизненный цикл, чтения, отмена
-await db.Запись(bkg.id).set({ status: 'confirmed' }).rows()
+await db.Запись(bkg.id).update({ status: 'confirmed' }).rows()
 await db.Запись(bkg.id).занятость().Окно().sort('data.start').rows()   // окна брони
 await db.Окно(w2.id).занятость({ kind: 'booking' }).Сотрудник().rows() // кто занят
 await db.Запись(bkg.id).delete().rows()                     // ПРЕВЬЮ: что удалится
@@ -2839,24 +2998,28 @@ const удалено = await db.Запись(bkg.id).delete({ confirm: true }).r
 ## 16. Тесты
 
 ```bash
-npm test    # 132 теста против живого docker (timescale + redis), по файлам:
+npm test    # 165/165 тестов против живого docker (timescale + redis), по файлам:
             # acl           — Resource/Rule: маски/weight/deny-by-default, шаблоны строк
             #                 с $account, enforceAcl (предикаты в SQL, каскад, watch)
             # api-full      — сквозной чек-лист ВСЕХ публичных методов API (15 групп)
             # auth          — db.auth: пароль/api-key/key-secret/TOTP/OTP/link+lookup,
             #                 глобальная идентичность, сессии на живом Redis (expire/revoke)
-            # plan          — план-модель: несколько операций, fan-out, self-set,
-            #                 превью/confirm delete, ОТКАТ плана, .link(), батч-гард
+            # plan          — план-модель: несколько операций, fan-out, self-update,
+            #                 превью/confirm delete, ОТКАТ плана, слот-перевес, батч-гард
             # resilience    — ретраи 40P01/40001, реальный deadlock двух транзакций,
             #                 watch переживает обрыв LISTEN (pg_terminate_backend)
             # core          — триггеры (check/версии/каскад/lineage), обходы, операторы,
-            #                 модификаторы, set-формы, delete, гонка, батчи, EXPLAIN
+            #                 модификаторы, create/update-формы, delete, гонка, батчи, EXPLAIN
             # depth         — наследование 3+ уровней, data-пути любой глубины
+            # idgen         — генерация id по Schema (§ 3.2): v4/v7/v5 из концов и полей,
+            #                 гонка без локов, наследование attributes и правила id, гарды
             # integration   — E2E-барбершоп (8 сцен)
             # real-life     — 16 сцен «дня салона»: 4 руки, гонки ×3, переносы, no-show
             # tables        — auth/ACL-таблицы
             # up            — up(): docker-argv, probe-ветка, идемпотентность, fresh,
             #                 свои сиды/seeds:false, автосоздание базы, валидация
+            # salon         — ТЕСТ-ПЛАН: имитация салона, ВСЕ 145 публичных API
+            #                 (21 акт + матрица покрытия); слоты/pivot/entity
             # wave2         — asOf/versions, keyset-курсор, gen-types, enforceAccount, anonymize
             # wave3         — or/not, агрегации, deep, watch
             # wave4         — compression-политики (чтение сжатого чанка), schema-sync, onQuery