letopis 0.20.3 → 1.0.0

package/dist/uuid.d.ts

@@ -1,6 +1,21 @@
-/** Namespace letopis для uuidv5 (фиксированная константа — стабильность id между релизами). */
-export declare const LETOPIS_NS = "c7a2f9d4-3b61-4e8a-9f05-8d2c1e6b7a90";
-/** RFC 4122 v5: sha1(namespace + name); детерминирован — одно имя → один uuid. */
-export declare function uuidv5(name: string, ns?: string): string;
-/** RFC 9562 v7: 48 бит unix-ms + random — время в старших битах, вставки ложатся в хвост индекса. */
-export declare function uuidv7(): string;
+/** RFC 4122 v5: sha1(пространство + имя); одно имя в одном пространстве — один id. */
+export declare function uuidv5(name: string, ns: string): string;
+/** Имя v5: JSON-массив из имени класса и значений ключа — как `jsonb_build_array(…)::text` в базе. */
+export declare function v5Name(cls: string, values: readonly string[]): string;
+/** id строки класса по значениям ключа в объявленном порядке. */
+export declare function v5Id(tenant: string, cls: string, values: readonly string[]): string;
+/** Что нужно idOf() о классе: имя, ключ и какие его части — концы (их значения — id целей). */
+export interface KeyedClass {
+    name: string;
+    key: readonly string[];
+    /** Имена концов класса: значение конца в ключе — id цели, он приводится к строчным буквам. */
+    ends?: readonly string[];
+}
+/**
+ * id объекта класса с ключом: `idOf(класс, { поле: значение, Роль: id }, { tenant })`. Значения
+ * ключевых полей — строки как есть (база их не нормализует), значения концов — id целей.
+ * Для класса без ключа id выдаёт база — ошибка `no_key`.
+ */
+export declare function idOf(cls: KeyedClass, key: Readonly<Record<string, unknown>>, opts: {
+    tenant: string;
+}): string;

package/dist/uuid.js

@@ -1,68 +1,52 @@
 /**
- * Генерация id по Schema (attributes.id):
- *   "uuid"                                    → v4 (random) — дефолт;
- *   { type: 'uuid', generate: 7 }             → v7 (unix-время в старших битах: btree-локальность);
- *   { type: 'uuid', generate: 5, from: […] }  → v5: sha1 от «схема:партиция:класс:значения from» —
- *     детерминированный id из концов/полей: та же комбинация → тот же id (идемпотентный create,
- *     дубль невозможен даже в гонке — оба запроса вычислят один id, второй станет версией).
+ * Идентификаторы v5 (план, §2.3, этап 2, п. 4).
+ *
+ * id = uuid_v5(арендатор, '["<класс>", "<значение 1>", …]'). Имя собирается так же, как в базе
+ * (`v5_name` в lib/sql/30-validate.sql — текстовый вид jsonb-массива): элементы через JSON.stringify,
+ * разделитель — запятая с пробелом. Совпадение закрепляет общий файл векторов lib/test/vectors/v5.json.
  */
-//
-// FILE: lib/src/uuid.ts
-// VERSION: 1.0.0
-// START_MODULE_CONTRACT
-//   PURPOSE: Детерминированная (v5) и упорядоченная по времени (v7) генерация UUID для id сущностей.
-//   SCOPE: namespace-константа LETOPIS_NS, форматирование 16 байт в каноничный UUID, v5 (sha1 от namespace+name), v7 (unix-ms в старших битах + random).
-//   DEPENDS: none
-//   LINKS: M-UUID, V-M-UUID
-//   ROLE: RUNTIME
-//   MAP_MODE: EXPORTS
-// END_MODULE_CONTRACT
-//
-// START_MODULE_MAP
-//   LETOPIS_NS - фиксированный namespace letopis для uuidv5 (стабильность id между релизами).
-//   fmt - (локальная) форматирует 16-байтный Buffer в каноничную строку UUID 8-4-4-4-12.
-//   uuidv5 - RFC 4122 v5: детерминированный uuid = sha1(namespace + name).
-//   uuidv7 - RFC 9562 v7: 48 бит unix-ms в старших битах + random.
-// END_MODULE_MAP
-//
-// START_CHANGE_SUMMARY
-//   LAST_CHANGE: [v1.0.0 - Documented existing module: reverse-engineered contract + markup]
-// END_CHANGE_SUMMARY
-import { createHash, randomBytes } from 'node:crypto';
-/** Namespace letopis для uuidv5 (фиксированная константа — стабильность id между релизами). */
-export const LETOPIS_NS = 'c7a2f9d4-3b61-4e8a-9f05-8d2c1e6b7a90';
-const fmt = (b) => {
-    const h = b.toString('hex');
-    return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20, 32)}`;
-};
-// START_CONTRACT: uuidv5
-//   PURPOSE: Детерминированный UUID v5 из имени и namespace (одно имя → один uuid).
-//   INPUTS: { name: string - имя (склеенные значения from класса), ns: string - namespace (default LETOPIS_NS) }
-//   OUTPUTS: { string - каноничный UUID v5 (version=5, variant=10xx) }
-//   SIDE_EFFECTS: none (чистая функция — только хэширование входа)
-//   LINKS: M-UUID, V-M-UUID
-// END_CONTRACT: uuidv5
-/** RFC 4122 v5: sha1(namespace + name); детерминирован — одно имя → один uuid. */
-export function uuidv5(name, ns = LETOPIS_NS) {
-    const nsBytes = Buffer.from(ns.replace(/-/g, ''), 'hex');
-    const h = createHash('sha1').update(nsBytes).update(name, 'utf8').digest().subarray(0, 16);
-    h[6] = (h[6] & 0x0f) | 0x50; // version 5
-    h[8] = (h[8] & 0x3f) | 0x80; // variant 10xx
-    return fmt(h);
+import { createHash } from 'node:crypto';
+import { LetopisError } from './errors.js';
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/** RFC 4122 v5: sha1(пространство + имя); одно имя в одном пространстве — один id. */
+export function uuidv5(name, ns) {
+    if (!UUID.test(ns))
+        throw new LetopisError('invalid_data', `пространство имён v5 — не uuid: ${ns}`);
+    const h = createHash('sha1').update(Buffer.from(ns.replace(/-/g, ''), 'hex')).update(name, 'utf8').digest().subarray(0, 16);
+    h[6] = (h[6] & 0x0f) | 0x50; // версия 5
+    h[8] = (h[8] & 0x3f) | 0x80; // вариант 10xx
+    const x = h.toString('hex');
+    return `${x.slice(0, 8)}-${x.slice(8, 12)}-${x.slice(12, 16)}-${x.slice(16, 20)}-${x.slice(20, 32)}`;
 }
-// START_CONTRACT: uuidv7
-//   PURPOSE: Упорядоченный по времени UUID v7 — 48 бит unix-ms в старших битах + random.
-//   INPUTS: { none }
-//   OUTPUTS: { string - каноничный UUID v7 (version=7, variant=10xx) }
-//   SIDE_EFFECTS: недетерминирован — читает Date.now() и криптослучайные байты (randomBytes)
-//   LINKS: M-UUID, V-M-UUID
-// END_CONTRACT: uuidv7
-/** RFC 9562 v7: 48 бит unix-ms + random — время в старших битах, вставки ложатся в хвост индекса. */
-export function uuidv7() {
-    const b = Buffer.alloc(16);
-    b.writeUIntBE(Date.now(), 0, 6);
-    randomBytes(10).copy(b, 6);
-    b[6] = (b[6] & 0x0f) | 0x70; // version 7
-    b[8] = (b[8] & 0x3f) | 0x80; // variant 10xx
-    return fmt(b);
+/** Имя v5: JSON-массив из имени класса и значений ключа — как `jsonb_build_array(…)::text` в базе. */
+export function v5Name(cls, values) {
+    return `[${[cls, ...values].map((v) => JSON.stringify(v)).join(', ')}]`;
+}
+/** id строки класса по значениям ключа в объявленном порядке. */
+export function v5Id(tenant, cls, values) {
+    return uuidv5(v5Name(cls, values), tenant);
+}
+/**
+ * id объекта класса с ключом: `idOf(класс, { поле: значение, Роль: id }, { tenant })`. Значения
+ * ключевых полей — строки как есть (база их не нормализует), значения концов — id целей.
+ * Для класса без ключа id выдаёт база — ошибка `no_key`.
+ */
+export function idOf(cls, key, opts) {
+    if (!cls.key.length) {
+        throw new LetopisError('no_key', `у класса ${cls.name} нет ключа: id выдаёт база при создании`);
+    }
+    const ends = new Set(cls.ends ?? []);
+    const values = cls.key.map((k) => {
+        const v = key[k];
+        if (typeof v !== 'string') {
+            throw new LetopisError('invalid_data', `idOf(${cls.name}): часть ключа ${k} должна быть строкой`, { key: cls.key });
+        }
+        if (ends.has(k)) {
+            if (!UUID.test(v))
+                throw new LetopisError('invalid_data', `idOf(${cls.name}): конец ${k} — не uuid`);
+            return v.toLowerCase();
+        }
+        return v;
+    });
+    return v5Id(opts.tenant, cls.name, values);
 }

package/dist/validate.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Валидатор на TypeScript (план, §2.6, этап 2, п. 11): та же проверка, что `compile_validator` и
+ * `validate_data` в lib/sql/30-validate.sql, — то же подмножество JSON Schema, те же пути и ключевые
+ * слова нарушений. Им пользуются загрузчик (этап 4) и ранние ошибки библиотеки; совпадение с базой
+ * закрепляет дифференциальный тест validator-parity.
+ *
+ * Как и в базе, правило — «нет узла по пути, нарушающего условие»: обычное правило даёт одно
+ * нарушение, сколько бы узлов его ни нарушили; дополнительные проверки (длина строки, uniqueItems,
+ * смысл даты, перечисления объектов, число ключей) — по нарушению на каждый узел.
+ */
+import { type Issue } from './errors.js';
+import { type JsonSchema } from './jsonschema.js';
+type J = unknown;
+/** Равенство значений JSON, как у jsonb: порядок ключей не важен, числа сравниваются по значению. */
+export declare function jsonEqual(a: J, b: J): boolean;
+export interface Validator {
+    /** Нарушения ([] — данные приняты). */
+    (data: unknown): Issue[];
+}
+/** Компилирует JSON Schema (разворот resolved.schema класса) в функцию проверки. */
+export declare function compileValidator(schema: JsonSchema): Validator;
+/** Умолчания, как apply_defaults в базе: на каждом уровне, во вложенные объекты — только если они есть. */
+export declare function applyDefaults(schema: JsonSchema, data: unknown): unknown;
+export {};

package/dist/validate.js

@@ -0,0 +1,251 @@
+/**
+ * Валидатор на TypeScript (план, §2.6, этап 2, п. 11): та же проверка, что `compile_validator` и
+ * `validate_data` в lib/sql/30-validate.sql, — то же подмножество JSON Schema, те же пути и ключевые
+ * слова нарушений. Им пользуются загрузчик (этап 4) и ранние ошибки библиотеки; совпадение с базой
+ * закрепляет дифференциальный тест validator-parity.
+ *
+ * Как и в базе, правило — «нет узла по пути, нарушающего условие»: обычное правило даёт одно
+ * нарушение, сколько бы узлов его ни нарушили; дополнительные проверки (длина строки, uniqueItems,
+ * смысл даты, перечисления объектов, число ключей) — по нарушению на каждый узел.
+ */
+import { LetopisError } from './errors.js';
+import { SUPPORTED, translatePattern } from './jsonschema.js';
+const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const typeOf = (v) => (v === null ? 'null' : Array.isArray(v) ? 'array' : typeof v === 'object' ? 'object' : typeof v === 'number' ? 'number' : typeof v === 'string' ? 'string' : typeof v === 'boolean' ? 'boolean' : 'unknown');
+/** Равенство значений JSON, как у jsonb: порядок ключей не важен, числа сравниваются по значению. */
+export function jsonEqual(a, b) {
+    if (typeof a === 'number' && typeof b === 'number')
+        return a === b;
+    if (typeOf(a) !== typeOf(b))
+        return false;
+    if (Array.isArray(a))
+        return a.length === b.length && a.every((x, i) => jsonEqual(x, b[i]));
+    if (isObj(a)) {
+        const ka = Object.keys(a);
+        const kb = Object.keys(b);
+        return ka.length === kb.length && ka.every((k) => Object.prototype.hasOwnProperty.call(b, k) && jsonEqual(a[k], b[k]));
+    }
+    return a === b;
+}
+/** Точная проверка кратности (в базе — numeric): через десятичную запись, без ошибок округления. */
+function isMultiple(x, m) {
+    const dec = (v) => {
+        const s = v.toString();
+        if (/e/i.test(s)) {
+            const [mant, exp] = s.toLowerCase().split('e');
+            const [i, f = ''] = mant.replace('-', '').split('.');
+            const e = Number(exp) - f.length;
+            const digits = BigInt(i + f) * (v < 0 ? -1n : 1n);
+            return e >= 0 ? [digits * 10n ** BigInt(e), 0] : [digits, -e];
+        }
+        const [i, f = ''] = s.replace('-', '').split('.');
+        return [BigInt(i + f) * (v < 0 ? -1n : 1n), f.length];
+    };
+    const [xi, xs] = dec(x);
+    const [mi, ms] = dec(m);
+    if (mi === 0n)
+        return false;
+    const scale = Math.max(xs, ms);
+    const X = xi * 10n ** BigInt(scale - xs);
+    const M = mi * 10n ** BigInt(scale - ms);
+    return X % M === 0n;
+}
+const FORMAT_RE = {
+    uuid: /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
+    date: /^[0-9]{4}-[0-9]{2}-[0-9]{2}$/,
+    'date-time': /^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(\.[0-9]{1,6})?(Z|[+-][0-9]{2}:[0-9]{2})$/,
+    email: /^[^@\s]+@[^@\s]+\.[^@\s]+$/,
+};
+/** Смысл даты и времени, как pg_input_is_valid(…, 'date' | 'timestamptz') для уже проверенной формы. */
+function validDate(s, withTime) {
+    const y = Number(s.slice(0, 4));
+    const mo = Number(s.slice(5, 7));
+    const d = Number(s.slice(8, 10));
+    if (y < 1 || mo < 1 || mo > 12 || d < 1)
+        return false;
+    const days = [31, (y % 4 === 0 && y % 100 !== 0) || y % 400 === 0 ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][mo - 1];
+    if (d > days)
+        return false;
+    if (!withTime)
+        return true;
+    const h = Number(s.slice(11, 13));
+    const mi = Number(s.slice(14, 16));
+    const se = Number(s.slice(17, 19));
+    if (h > 24 || mi > 59 || se > 60)
+        return false;
+    if (h === 24 && (mi > 0 || se > 0 || /\.[0-9]*[1-9]/.test(s.slice(19))))
+        return false;
+    const tz = /([+-])([0-9]{2}):([0-9]{2})$/.exec(s);
+    if (tz && (Number(tz[2]) > 15 || Number(tz[3]) > 59))
+        return false;
+    return true;
+}
+const TYPE_TEST = {
+    integer: (v) => typeof v === 'number' && Number.isInteger(v),
+    number: (v) => typeof v === 'number',
+    string: (v) => typeof v === 'string',
+    boolean: (v) => typeof v === 'boolean',
+    object: isObj,
+    array: Array.isArray,
+    null: (v) => v === null,
+};
+const prop = (sel, k) => (root) => sel(root).flatMap((n) => (isObj(n) && Object.prototype.hasOwnProperty.call(n, k) ? [n[k]] : []));
+const items = (sel) => (root) => sel(root).flatMap((n) => (Array.isArray(n) ? n : []));
+const others = (sel, known) => (root) => sel(root).flatMap((n) => (isObj(n) ? Object.keys(n).filter((k) => !known.includes(k)).map((k) => n[k]) : []));
+const keys = (sel) => (root) => sel(root).flatMap((n) => (isObj(n) ? Object.keys(n) : []));
+function fail(path, msg) {
+    throw new LetopisError('invalid_class', `${msg} (узел ${JSON.stringify(path)})`);
+}
+/** Компиляция узла схемы в правила — порядок и состав как в jp_compile. */
+function compileNode(s, sel, path, inAny, out) {
+    if (s === undefined || s === true || (isObj(s) && Object.keys(s).length === 0))
+        return;
+    if (!isObj(s))
+        fail(path, `описание узла ${JSON.stringify(path)} — не объект`);
+    const sch = s;
+    for (const k of Object.keys(sch)) {
+        if (!SUPPORTED.has(k) && !k.startsWith('x-'))
+            fail(path, `ключевое слово ${k} не поддерживается`);
+    }
+    if (sch.type !== undefined) {
+        const types = Array.isArray(sch.type) ? sch.type : [sch.type];
+        const tests = types.map((t) => TYPE_TEST[t] ?? fail(path, `неизвестный тип в узле ${JSON.stringify(path)}`));
+        out.push({ path, keyword: 'type', select: sel, test: (v) => tests.some((f) => f(v)) });
+    }
+    if (sch.enum !== undefined || sch.const !== undefined) {
+        const keyword = sch.enum !== undefined ? 'enum' : 'const';
+        const values = (sch.enum ?? [sch.const]);
+        if (values.some((v) => typeof v === 'object' && v !== null)) {
+            if (inAny)
+                fail(path, 'перечисление объектов внутри anyOf не поддерживается');
+            out.push({ path, keyword, select: sel, test: () => true, extra: (v) => (values.some((x) => jsonEqual(x, v)) ? null : 'значение не из перечисления') });
+        }
+        else {
+            out.push({ path, keyword, select: sel, test: (v) => values.some((x) => typeOf(x) === typeOf(v) && jsonEqual(x, v)) });
+        }
+    }
+    const num = (f, b) => (v) => typeof v !== 'number' || f(v, b);
+    if (sch.minimum !== undefined)
+        out.push({ path, keyword: 'minimum', select: sel, test: num((v, b) => v >= b, sch.minimum) });
+    if (sch.maximum !== undefined)
+        out.push({ path, keyword: 'maximum', select: sel, test: num((v, b) => v <= b, sch.maximum) });
+    if (sch.exclusiveMinimum !== undefined)
+        out.push({ path, keyword: 'exclusiveMinimum', select: sel, test: num((v, b) => v > b, sch.exclusiveMinimum) });
+    if (sch.exclusiveMaximum !== undefined)
+        out.push({ path, keyword: 'exclusiveMaximum', select: sel, test: num((v, b) => v < b, sch.exclusiveMaximum) });
+    if (sch.multipleOf !== undefined)
+        out.push({ path, keyword: 'multipleOf', select: sel, test: num((v, b) => isMultiple(v, b), sch.multipleOf) });
+    if (sch.pattern !== undefined) {
+        const re = new RegExp(translatePattern(sch.pattern));
+        out.push({ path, keyword: 'pattern', select: sel, test: (v) => typeof v !== 'string' || re.test(v) });
+    }
+    if (sch.format !== undefined) {
+        const f = sch.format;
+        const re = FORMAT_RE[f] ?? fail(path, `format ${f} не поддерживается`);
+        out.push({ path, keyword: 'format', select: sel, test: (v) => typeof v !== 'string' || re.test(v) });
+        if (f === 'date' || f === 'date-time') {
+            if (inAny)
+                fail(path, `format ${f} внутри anyOf не поддерживается`);
+            out.push({ path, keyword: 'format', select: sel, test: () => true,
+                extra: (v) => (typeof v !== 'string' || !re.test(v) || validDate(v, f === 'date-time') ? null : 'такой даты не бывает') });
+        }
+    }
+    if (sch.minLength !== undefined || sch.maxLength !== undefined) {
+        if (inAny)
+            fail(path, 'длина строки внутри anyOf не поддерживается');
+        const min = sch.minLength ?? 0;
+        const max = sch.maxLength ?? Infinity;
+        out.push({ path, keyword: sch.minLength !== undefined ? 'minLength' : 'maxLength', select: sel, test: () => true,
+            extra: (v) => { if (typeof v !== 'string')
+                return null; const n = [...v].length; return n < min || n > max ? 'длина строки вне границ' : null; } });
+    }
+    if (sch.minItems !== undefined)
+        out.push({ path, keyword: 'minItems', select: sel, test: (v) => !Array.isArray(v) || v.length >= sch.minItems });
+    if (sch.maxItems !== undefined)
+        out.push({ path, keyword: 'maxItems', select: sel, test: (v) => !Array.isArray(v) || v.length <= sch.maxItems });
+    if (sch.uniqueItems === true) {
+        if (inAny)
+            fail(path, 'uniqueItems внутри anyOf не поддерживается');
+        out.push({ path, keyword: 'uniqueItems', select: sel, test: () => true,
+            extra: (v) => (Array.isArray(v) && v.some((x, i) => v.findIndex((y) => jsonEqual(x, y)) !== i) ? 'элементы повторяются' : null) });
+    }
+    if (sch.items !== undefined)
+        compileNode(sch.items, items(sel), [...path, '*'], inAny, out);
+    if (Array.isArray(sch.required)) {
+        for (const k of sch.required)
+            out.push({ path: [...path, k], keyword: 'required', select: sel, test: (v) => !isObj(v) || Object.prototype.hasOwnProperty.call(v, k) });
+    }
+    if (sch.minProperties !== undefined || sch.maxProperties !== undefined) {
+        if (inAny)
+            fail(path, 'minProperties внутри anyOf не поддерживается');
+        const min = sch.minProperties ?? 0;
+        const max = sch.maxProperties ?? Infinity;
+        out.push({ path, keyword: sch.minProperties !== undefined ? 'minProperties' : 'maxProperties', select: sel, test: () => true,
+            extra: (v) => { if (!isObj(v))
+                return null; const n = Object.keys(v).length; return n < min || n > max ? 'число ключей вне границ' : null; } });
+    }
+    const known = isObj(sch.properties) ? Object.keys(sch.properties) : [];
+    if (isObj(sch.properties)) {
+        for (const [k, v] of Object.entries(sch.properties))
+            compileNode(v, prop(sel, k), [...path, k], inAny, out);
+    }
+    if (sch.additionalProperties === false) {
+        out.push({ path, keyword: 'additionalProperties', select: sel, test: (v) => !isObj(v) || Object.keys(v).every((k) => known.includes(k)) });
+    }
+    else if (isObj(sch.additionalProperties)) {
+        compileNode(sch.additionalProperties, others(sel, known), [...path, '*'], inAny, out);
+    }
+    if (sch.propertyNames !== undefined) {
+        compileNode({ ...sch.propertyNames, type: 'string' }, keys(sel), [...path, '<ключ>'], inAny, out);
+    }
+    for (const kw of ['anyOf', 'oneOf']) {
+        if (!Array.isArray(sch[kw]))
+            continue;
+        const branches = sch[kw].map((b) => {
+            const rules = [];
+            compileNode(b, (root) => [root], path, true, rules);
+            return (node) => rules.every((r) => r.select(node).every((n) => r.test(n)));
+        });
+        out.push({ path, keyword: kw, select: sel, test: kw === 'anyOf'
+                ? (v) => branches.some((b) => b(v))
+                : (v) => branches.filter((b) => b(v)).length === 1 });
+    }
+}
+/** Компилирует JSON Schema (разворот resolved.schema класса) в функцию проверки. */
+export function compileValidator(schema) {
+    const rules = [];
+    compileNode(schema, (root) => [root], [], false, rules);
+    return (data) => {
+        const issues = [];
+        for (const r of rules) {
+            const nodes = r.select(data);
+            if (r.extra) {
+                for (const n of nodes) {
+                    const msg = r.extra(n);
+                    if (msg)
+                        issues.push({ path: r.path, keyword: r.keyword, message: msg });
+                }
+            }
+            else if (!nodes.every((n) => r.test(n))) {
+                issues.push({ path: r.path, keyword: r.keyword, message: `нарушено правило ${r.keyword}` });
+            }
+        }
+        return issues;
+    };
+}
+/** Умолчания, как apply_defaults в базе: на каждом уровне, во вложенные объекты — только если они есть. */
+export function applyDefaults(schema, data) {
+    if (!isObj(data) || !isObj(schema.properties))
+        return data;
+    const out = { ...data };
+    for (const [k, s] of Object.entries(schema.properties)) {
+        if (!Object.prototype.hasOwnProperty.call(out, k)) {
+            if (isObj(s) && 'default' in s)
+                out[k] = structuredClone(s.default);
+        }
+        else if (isObj(out[k]) && isObj(s)) {
+            out[k] = applyDefaults(s, out[k]);
+        }
+    }
+    return out;
+}

package/dist/watch.d.ts

@@ -0,0 +1,62 @@
+import type { Executor } from './tx.js';
+import type { Row } from './types.js';
+export interface WatchOptions {
+    /** Откуда: курсор события, 'now' (по умолчанию — изменения после подписки) или 'start' (весь журнал). */
+    from?: string;
+    /** Только эти классы (с потомками). */
+    classes?: string[];
+    /** Событий за запрос (по умолчанию 500). */
+    batch?: number;
+    /** Запасной опрос, мс (по умолчанию 1000; без LISTEN — единственный способ узнать о событиях). */
+    pollMs?: number;
+}
+export interface WatchEvent {
+    /** Курсор этого события: watch({ from: cursor }) продолжит после него. */
+    cursor: string;
+    /** Версия из журнала (надгробие — $deleted). */
+    row: Row;
+    id: string;
+    class: string;
+    op: string;
+    rev: number;
+    at: string;
+}
+export interface WatchCtx {
+    S: string;
+    exec: Executor;
+    /** Классы подписки с потомками (null — все). */
+    classes: string[] | null;
+    /** Подписка на сигналы базы; возвращает отписку. */
+    onSignal?: (fn: (name: string) => void) => () => void;
+}
+export declare class Subscription implements AsyncIterable<WatchEvent> {
+    private ctx;
+    private opts;
+    private pos;
+    private buf;
+    private closed;
+    private wake;
+    private dirty;
+    private off;
+    private timer;
+    private failure;
+    private readonly batch;
+    private readonly pollMs;
+    /** 'now' — голова журнала в момент подписки (запрос уходит сразу). */
+    private start;
+    constructor(ctx: WatchCtx, opts: WatchOptions);
+    /** Курсор последнего выданного события (или начальной точки). */
+    get cursor(): string | null;
+    private head;
+    /** Следующая пачка событий ниже горизонта; пусто — горизонт ещё не дошёл или событий нет. */
+    private fetch;
+    next(): Promise<IteratorResult<WatchEvent>>;
+    /**
+     * Отставание, мс: сколько ждёт самое старое событие, которое уже зафиксировано, но ещё не ушло за
+     * горизонт (его держит более старая открытая транзакция); 0 — ждать нечего.
+     */
+    lag(): Promise<number>;
+    close(): void;
+    return(): Promise<IteratorResult<WatchEvent>>;
+    [Symbol.asyncIterator](): AsyncIterator<WatchEvent>;
+}