odant-work 1.0.12 → 1.0.13

package/sources/data/posting.js

@@ -0,0 +1,657 @@
+/**
+ * Проведение операций: проводки единого журнала по правилам класса.
+ *
+ * Правило (POSTINGS, собирается по наследованию в schema.js):
+ *   { id, each?, when?, amount?, qty?, unit?, item?, qty2?,
+ *     debit: { account, analytics: { слот: выражение } }, credit: { ... } }
+ *   - each   — табличная часть: проводка на каждую строку (в выражениях `row`);
+ *   - when   — условие: ложь — проводки нет;
+ *   - amount — сумма в рублях (хранится в копейках);
+ *   - qty    — количество в единице документа; с `unit` и `item` пересчитывается
+ *              в базовую единицу номенклатуры (её `base_unit` и табличная часть
+ *              `units`: { unit, coef }); в проводке — базовое, а также doc_qty/doc_unit;
+ *   - qty2   — второе измерение (масса при учёте в литрах и т. п.);
+ *   - аналитики счёта — выражения, дающие id объекта целевого класса слота.
+ *   Строка, где сумма и количества нулевые, проводки не даёт.
+ *
+ * Функции выражений: norm(вид, объект?, поУмолчанию?) — норматив на дату
+ * операции (остаток количества счёта нормативов, см. normValue);
+ * coef(номенклатура, единица) — коэффициент единицы к базовой;
+ * unit_cost(счёт, номенклатура, склад?, партия?, поУмолчанию?) — скользящая средняя
+ * стоимость базовой единицы остатка на дату операции (см. unitCost).
+ *
+ * Автоаналитики проводки — колонки: операция, её класс, автор действия,
+ * рабочее место и подразделение операции.
+ *
+ * Жизненный цикл (docs/architecture-v2.md, Р1): регистрация — проводки в той же
+ * транзакции; исправление — новая версия, сторно действующих проводок и новые
+ * проводки; отмена — сторно. Дата в закрытом периоде: регистрировать и переносить
+ * туда нельзя, а сторно и новые проводки исправления датируются текущим моментом.
+ */
+import { tx, getSetting, setSetting } from './db.js';
+import { getClass, descendants, classesOfType, classesGeneration } from './classes.js';
+import { classSchema, checkSchema, analyticSlots, classBasePath, resolveInBase } from './schema.js';
+import { compile, toNumber, round, ExprError } from './expr.js';
+import { readObject, writeVersion, validateBody, linkCids, mergeBody } from './objects.js';
+import { DataError } from './errors.js';
+import { parseTime, localDay, dayStart, nextDay } from './time.js';
+
+const isEmpty = v => v === undefined || v === null || v === '';
+const num = v => toNumber(v, msg => { throw new DataError(msg); });
+
+/* ---------- закрытый период ---------- */
+
+const CLOSED_KEY = 'closed_until';
+
+/** Последний закрытый день 'YYYY-MM-DD' (включительно) или null. */
+export function closedUntil(db) {
+    return getSetting(db, CLOSED_KEY) ?? null;
+}
+
+/** Момент попадает в закрытый период. */
+export function isClosed(db, time) {
+    const day = closedUntil(db);
+    return !!day && time < nextDay(dayStart(day));
+}
+
+/**
+ * Закрыть период по день включительно (null — открыть всё).
+ * Закрыть можно только прошедший день: исправления в закрытом периоде датируются сегодняшним.
+ */
+export function closePeriod(db, day) {
+    if (isEmpty(day)) {
+        setSetting(db, CLOSED_KEY, null);
+        return null;
+    }
+    const s = String(day).trim();
+    if (nextDay(dayStart(s)) > Date.now())
+        throw new DataError(`закрыть можно только прошедший день, а не ${s}`);
+    setSetting(db, CLOSED_KEY, s);
+    return s;
+}
+
+function closedError(db, what) {
+    return new DataError(`период по ${closedUntil(db)} закрыт — ${what}`);
+}
+
+/* ---------- нормативы ---------- */
+
+const normsCache = new WeakMap();
+
+/**
+ * Счёт нормативов: класс счёта с `NORMS: true` или `NORMS: { kind, object }` —
+ * имена слотов-аналитик вида норматива и объекта (по умолчанию 'kind' и 'object').
+ */
+function normsAccount(db) {
+    const gen = classesGeneration(db);
+    const hit = normsCache.get(db);
+    if (hit && hit.gen === gen)
+        return hit.acc;
+    let list = classesOfType(db, '$account').filter(c => c.own?.NORMS || classSchema(db, c.cid)?.norms);
+    const nonModule = list.filter(c => !c.path.startsWith('/MODULES/'));
+    if (nonModule.length)
+        list = nonModule;
+    // Внутри одного журнала ($register) счёт нормативов должен быть единственным
+    const byRegister = new Map();
+    for (const c of list) {
+        const reg = c.parent || '';
+        const prev = byRegister.get(reg) || [];
+        prev.push(c);
+        if (prev.length > 1)
+            throw new DataError(`счетов нормативов несколько: ${prev.map(x => x.path).join(', ')} — NORMS должен быть у одного`);
+        byRegister.set(reg, prev);
+    }
+    let acc = null;
+    if (list.length) {
+        const c = list[0];
+        const rawNorms = c.own?.NORMS ?? classSchema(db, c.cid)?.norms;
+        const spec = (rawNorms && typeof rawNorms === 'object') ? rawNorms : {};
+        const kind = String(spec.kind || 'kind');
+        const allCids = new Set();
+        const allKindCids = new Set();
+        for (const item of list) {
+            for (const cid of descendants(db, item.cid))
+                allCids.add(cid);
+            const slot = analyticSlots(classSchema(db, item.cid)).find(f => f.id === kind);
+            for (const kcid of (slot ? linkCids(db, slot.target) ?? [] : []))
+                allKindCids.add(kcid);
+        }
+        acc = {
+            cid: c.cid,
+            label: c.label,
+            cids: [...allCids],
+            kind,
+            object: String(spec.object || 'object'),
+            kindCids: allKindCids.size ? [...allKindCids] : null,
+        };
+    }
+    normsCache.set(db, { gen, acc });
+    return acc;
+}
+
+function resolveKind(db, acc, kind) {
+    const key = String(typeof kind === 'object' && kind ? kind.id : kind ?? '').trim();
+    if (!key)
+        throw new DataError('norm(): не задан вид норматива');
+    if (!acc.kindCids)
+        throw new DataError(`у счёта нормативов ${acc.label} нет аналитики «${acc.kind}»`);
+    const marks = acc.kindCids.map(() => '?').join(',') || "''";
+    const byId = db.prepare(`SELECT id FROM objects WHERE id = ? AND cid IN (${marks})`).get(key, ...acc.kindCids);
+    if (byId)
+        return byId.id;
+    const byName = db.prepare(`SELECT id FROM objects WHERE cid IN (${marks}) AND status <> 'deleted'
+        AND json_extract(body, '$.name') = ? ORDER BY created LIMIT 1`).get(...acc.kindCids, key);
+    if (!byName)
+        throw new DataError(`вид норматива «${key}» не найден`);
+    return byName.id;
+}
+
+/**
+ * Норматив на момент: остаток количества (Дт − Кт) счёта нормативов по виду и объекту.
+ * С объектом — сначала его собственный норматив, затем общий (без объекта).
+ * С `fallback` поиск только точный, а при отсутствии значения возвращается fallback
+ * (так операция «Установка норматива» считает разницу: `value - norm(kind, object, 0)`).
+ * @param {object} [opts] { fallback?, exclude? — id операции, чьи проводки не учитываются }
+ */
+export function normValue(db, kind, object, at, { fallback, exclude = '' } = {}) {
+    const acc = normsAccount(db);
+    if (!acc)
+        throw new DataError('счёт нормативов не настроен (NORMS: true в class.js счёта)');
+    const kindId = resolveKind(db, acc, kind);
+    const moment = parseTime(at ?? Date.now(), 'дата норматива');
+    const marks = acc.cids.map(() => '?').join(',');
+    const lookup = obj => {
+        let n = 0, v = 0;
+        for (const [side, col] of [['D', 'debit_cid'], ['C', 'credit_cid']]) {
+            const objCond = obj
+                ? 'EXISTS (SELECT 1 FROM entry_analytics o WHERE o.entry_id = e.id AND o.side = ? AND o.slot = ? AND o.ref_id = ?)'
+                : 'NOT EXISTS (SELECT 1 FROM entry_analytics o WHERE o.entry_id = e.id AND o.side = ? AND o.slot = ?)';
+            const r = db.prepare(`SELECT coalesce(sum(CASE WHEN e.storno THEN -1 ELSE 1 END), 0) n, coalesce(sum(e.qty), 0) q
+                FROM entries e JOIN entry_analytics k ON k.entry_id = e.id AND k.side = ? AND k.slot = ? AND k.ref_id = ?
+                WHERE e.${col} IN (${marks}) AND e.time <= ? AND e.op_id <> ? AND ${objCond}`)
+                .get(side, acc.kind, kindId, ...acc.cids, moment, String(exclude), side, acc.object, ...(obj ? [obj] : []));
+            n += r.n;
+            v += side === 'D' ? r.q : -r.q;
+        }
+        return n > 0 ? round(v, 10) : undefined;
+    };
+    const objId = isEmpty(object) ? null : String(typeof object === 'object' ? object.id : object);
+    if (fallback !== undefined)
+        return lookup(objId) ?? fallback;
+    const v = (objId ? lookup(objId) : undefined) ?? lookup(null);
+    if (v === undefined)
+        throw new DataError(`норматив «${kind}» не задан на ${localDay(moment)}`);
+    return v;
+}
+
+/* ---------- единицы ---------- */
+
+/** Коэффициент единицы к базовой единице номенклатуры (версия объекта на момент). */
+export function unitCoef(db, item, unit, at) {
+    const u = String(unit ?? '').trim();
+    if (!u)
+        return 1;
+    const id = String(typeof item === 'object' && item ? item.id : item ?? '');
+    if (!id)
+        throw new DataError(`единица «${u}» без номенклатуры`);
+    const obj = readObject(db, id, { at }) ?? readObject(db, id);
+    if (!obj)
+        throw new DataError(`номенклатура ${id} не найдена`);
+    const same = x => String(x ?? '').trim().toLowerCase() === u.toLowerCase();
+    if (same(obj.body.base_unit))
+        return 1;
+    const row = (Array.isArray(obj.body.units) ? obj.body.units : []).find(r => same(r?.unit));
+    if (!row)
+        throw new DataError(`у «${obj.title || id}» нет единицы «${u}»`);
+    const k = num(row.coef);
+    if (!(k > 0))
+        throw new DataError(`у «${obj.title || id}» коэффициент единицы «${u}» не положителен`);
+    return k;
+}
+
+/* ---------- себестоимость ---------- */
+
+const COST_SLOTS = ['item', 'storage', 'batch'];
+
+/**
+ * Скользящая средняя: стоимость единицы остатка счёта (в базовой единице) на момент операции —
+ * сальдо суммы, делённое на сальдо количества. Остаток отбирается по аналитикам счёта
+ * `item`, `storage`, `batch` (пустые не учитываются); проводки самой операции не берутся,
+ * поэтому исправление считает цену заново. Остатка нет: ошибка, а с `fallback` — он.
+ * @param {object} p { account, item, storage?, batch?, at, exclude?, fallback? }
+ */
+export function unitCost(db, { account, item, storage, batch, at, exclude = '', excludeIds = null, fallback } = {}) {
+    const cls = getClass(db, account);
+    if (!cls || cls.type !== '$account')
+        throw new DataError(`unit_cost(): счёт ${account} не найден`);
+    const slots = analyticSlots(classSchema(db, cls.cid)).map(f => f.id);
+    const want = { item, storage, batch };
+    const cond = [], args = [];
+    for (const slot of COST_SLOTS) {
+        const v = want[slot];
+        if (isEmpty(v))
+            continue;
+        if (!slots.includes(slot))
+            throw new DataError(`unit_cost(): у счёта ${cls.label} нет аналитики «${slot}»`);
+        cond.push(slot);
+        args.push(slot, String(typeof v === 'object' ? v.id : v));
+    }
+    if (!cond.includes('item'))
+        throw new DataError('unit_cost(): не задана номенклатура');
+    const moment = parseTime(at ?? Date.now(), 'дата себестоимости');
+    const accs = descendants(db, cls.cid);
+    const marks = accs.map(() => '?').join(',');
+    const exclList = Array.isArray(excludeIds) && excludeIds.length
+        ? excludeIds.map(String)
+        : [String(exclude)];
+    const exclMarks = exclList.map(() => '?').join(',');
+    let amount = 0, qty = 0, n = 0;
+    for (const [side, col, sign] of [['D', 'debit_cid', 1], ['C', 'credit_cid', -1]]) {
+        const exists = cond.map(() => 'EXISTS (SELECT 1 FROM entry_analytics a WHERE a.entry_id = e.id AND a.side = ? AND a.slot = ? AND a.ref_id = ?)').join(' AND ');
+        const params = [];
+        for (let i = 0; i < args.length; i += 2)
+            params.push(side, args[i], args[i + 1]);
+        const r = db.prepare(`SELECT count(*) n, coalesce(sum(e.amount), 0) a, coalesce(sum(e.qty), 0) q FROM entries e
+            WHERE e.${col} IN (${marks}) AND e.time <= ? AND e.op_id NOT IN (${exclMarks}) AND ${exists}`).get(...accs, moment, ...exclList, ...params);
+        n += r.n;
+        amount += sign * r.a;
+        qty += sign * r.q;
+    }
+    if (n === 0 || Math.abs(qty) < 1e-9) {
+        if (fallback !== undefined)
+            return fallback;
+        throw new DataError(`unit_cost(): остатка нет — себестоимость на ${localDay(moment)} не определить (${cls.label})`);
+    }
+    return round(amount / 100 / qty, 6);
+}
+
+/* ---------- расчёт проводок ---------- */
+
+const rulesCache = new WeakMap();
+
+/** Правила класса операции готовы к проведению (checkSchema без ошибок; кэш до изменения классов). */
+function assertRules(db, schema) {
+    const gen = classesGeneration(db);
+    let byDb = rulesCache.get(db);
+    if (!byDb || byDb.gen !== gen) {
+        byDb = { gen, map: new Map() };
+        rulesCache.set(db, byDb);
+    }
+    if (!byDb.map.has(schema.cid))
+        byDb.map.set(schema.cid, schema.leaf ? checkSchema(db, schema.cid) : [`${schema.path}: операции проводятся только в конечном классе`]);
+    const errors = byDb.map.get(schema.cid);
+    if (errors.length)
+        throw new DataError(`${schema.label}: правила проводок не готовы`, errors.map(message => ({ message })));
+}
+
+function sideOf(db, rule, side, scope, fns) {
+    const name = side === 'debit' ? 'дебет' : 'кредит';
+    const cls = getClass(db, rule[side]?.account);
+    if (!cls)
+        throw new DataError(`счёт ${rule[side]?.account} (${name}) не найден`);
+    const acc = classSchema(db, cls.cid);
+    const analytics = {};
+    for (const slot of analyticSlots(acc)) {
+        const src = rule[side].analytics?.[slot.id];
+        let v = isEmpty(src) ? undefined : compile(src).run(scope, fns);
+        if (v && typeof v === 'object' && !Array.isArray(v))
+            v = v.id;
+        if (isEmpty(v)) {
+            if (slot.required)
+                throw new DataError(`аналитика «${slot.label}» счёта ${acc.label} (${name}) не заполнена`);
+            continue;
+        }
+        if (Array.isArray(v))
+            throw new DataError(`аналитика «${slot.label}» счёта ${acc.label} (${name}) — список, а не один объект`);
+        const id = String(v);
+        const obj = db.prepare('SELECT cid, status FROM objects WHERE id = ?').get(id);
+        const cids = linkCids(db, slot.target);
+        if (!obj || !cids?.includes(obj.cid) || obj.status === 'deleted')
+            throw new DataError(`аналитика «${slot.label}» счёта ${acc.label} (${name}): объект ${id} не найден в ${getClass(db, slot.target)?.label ?? slot.target}`);
+        analytics[slot.id] = { ref_id: id, ref_cid: obj.cid };
+    }
+    return { cid: cls.cid, analytics };
+}
+
+/**
+ * Проводки операции по правилам класса (без записи).
+ * @param {object} op { id, cid, time, body }
+ * @returns {{ entries: object[], errors: Array<{field, message}> }} amount — в копейках
+ */
+function computeEntries(db, schema, op, { excludeIds = null } = {}) {
+    const entries = [], errors = [];
+    const basePath = classBasePath(db, schema.cid);
+    const fns = {
+        norm: (...a) => normValue(db, a[0], a[1], op.time, { exclude: op.id, ...(a.length >= 3 ? { fallback: a[2] } : {}) }),
+        coef: (item, unit) => unitCoef(db, item, unit, op.time),
+        unit_cost: (account, item, storage, batch, ...rest) => unitCost(db, {
+            account: basePath ? resolveInBase(db, basePath, account) : account,
+            item, storage, batch, at: op.time, exclude: op.id, excludeIds, ...(rest.length ? { fallback: rest[0] } : {}),
+        }),
+    };
+    for (const rule of schema.postings) {
+        const rows = rule.each ? (Array.isArray(op.body[rule.each]) ? op.body[rule.each] : []) : [null];
+        rows.forEach((row, i) => {
+            const where = rule.each ? `правило «${rule.id}», строка ${i + 1}` : `правило «${rule.id}»`;
+            try {
+                const scope = rule.each ? { ...op.body, row } : { ...op.body };
+                const ev = key => (isEmpty(rule[key]) ? undefined : compile(rule[key]).run(scope, fns));
+                if (!isEmpty(rule.when) && !ev('when'))
+                    return;
+                const amount = Math.round(round(num(ev('amount')), 2) * 100);
+                const docQty = num(ev('qty'));
+                const unit = isEmpty(rule.unit) ? '' : String(ev('unit') ?? '').trim();
+                const qty = round(unit ? docQty * unitCoef(db, ev('item'), unit, op.time) : docQty, 6);
+                const qty2 = round(num(ev('qty2')), 6);
+                if (!amount && !qty && !qty2)
+                    return;
+                const debit = sideOf(db, rule, 'debit', scope, fns);
+                const credit = sideOf(db, rule, 'credit', scope, fns);
+                entries.push({
+                    rule: rule.id,
+                    row: rule.each ? i : -1,
+                    debit_cid: debit.cid,
+                    credit_cid: credit.cid,
+                    amount,
+                    qty,
+                    qty2,
+                    doc_qty: unit ? docQty : null,
+                    doc_unit: unit || null,
+                    analytics: { D: debit.analytics, C: credit.analytics },
+                });
+            }
+            catch (e) {
+                if (!(e instanceof DataError || e instanceof ExprError))
+                    throw e;
+                errors.push({ field: where, message: e.message });
+            }
+        });
+    }
+    return { entries, errors };
+}
+
+function insertEntries(db, op, entries, { time, version, author, storno = false, now }) {
+    const ins = db.prepare(`INSERT INTO entries (op_id, op_version, op_cid, rule, row, time, debit_cid, credit_cid,
+        amount, qty, qty2, doc_qty, doc_unit, author, place, unit, storno, created)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+    const insA = db.prepare('INSERT INTO entry_analytics (entry_id, side, slot, ref_id, ref_cid) VALUES (?, ?, ?, ?, ?)');
+    const insAcc = db.prepare(`INSERT INTO account_entries (entry_id, side, account_cid, corr_cid, op_id, op_version, op_cid,
+        rule, row, time, debit, credit, qty_in, qty_out, qty2, doc_qty, doc_unit, analytics, author, place, unit, storno, created)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+    for (const e of entries) {
+        const sign = storno ? -1 : 1;
+        const entryTime = e.time ?? time;
+        const entryAuthor = author ?? op.author ?? null;
+        const amt = sign * e.amount;
+        const q = sign * e.qty;
+        const q2 = sign * e.qty2;
+        const docQty = e.doc_qty === null ? null : sign * e.doc_qty;
+        const stornoFlag = storno ? 1 : 0;
+        const res = ins.run(op.id, version, op.cid, e.rule, e.row, entryTime, e.debit_cid, e.credit_cid,
+            amt, q, q2, docQty, e.doc_unit, entryAuthor, op.place ?? null, op.unit ?? null, stornoFlag, now);
+        const id = Number(res.lastInsertRowid);
+        const sideJson = side => JSON.stringify(Object.fromEntries(Object.entries(e.analytics[side] || {}).map(([slot, a]) => [slot, a.ref_id])));
+        // Явная двойная запись: отдельная запись в счёте Дебета и отдельная запись в счёте Кредита
+        insAcc.run(id, 'D', e.debit_cid, e.credit_cid, op.id, version, op.cid, e.rule, e.row, entryTime,
+            amt, 0, q, 0, q2, docQty, e.doc_unit, sideJson('D'), entryAuthor, op.place ?? null, op.unit ?? null, stornoFlag, now);
+        insAcc.run(id, 'C', e.credit_cid, e.debit_cid, op.id, version, op.cid, e.rule, e.row, entryTime,
+            0, amt, 0, q, q2, docQty, e.doc_unit, sideJson('C'), entryAuthor, op.place ?? null, op.unit ?? null, stornoFlag, now);
+        for (const side of ['D', 'C']) {
+            for (const [slot, a] of Object.entries(e.analytics[side]))
+                insA.run(id, side, slot, a.ref_id, a.ref_cid);
+        }
+    }
+}
+
+/** Действующие проводки операции: последней версии проведения, без сторно (amount в копейках). */
+function effectiveRows(db, opId) {
+    const rows = db.prepare(`SELECT * FROM entries WHERE op_id = ? AND storno = 0
+        AND op_version = (SELECT max(op_version) FROM entries WHERE op_id = ?) ORDER BY id`).all(opId, opId);
+    return rows.map(r => ({ ...r, analytics: analyticsOf(db, r.id) }));
+}
+
+function analyticsOf(db, entryId) {
+    const out = { D: {}, C: {} };
+    for (const a of db.prepare('SELECT side, slot, ref_id, ref_cid FROM entry_analytics WHERE entry_id = ?').all(entryId))
+        out[a.side][a.slot] = { ref_id: a.ref_id, ref_cid: a.ref_cid };
+    return out;
+}
+
+/** Сторно действующих проводок: дата прежняя, а в закрытом периоде — now. */
+function stornoEntries(db, op, version, author, now) {
+    const rows = effectiveRows(db, op.id).map(e => ({ ...e, time: isClosed(db, e.time) ? now : e.time }));
+    insertEntries(db, op, rows, { version, author, storno: true, now });
+    return rows.length;
+}
+
+/** Собрать id номенклатур (слот item) из списка проводок. */
+function collectItemIds(entries) {
+    const ids = new Set();
+    for (const e of entries || []) {
+        for (const side of ['D', 'C']) {
+            const ref = e?.analytics?.[side]?.item?.ref_id;
+            if (ref)
+                ids.add(String(ref));
+        }
+    }
+    return ids;
+}
+
+function schemaUsesUnitCost(schema) {
+    for (const r of schema?.postings || []) {
+        if (/\bunit_cost\s*\(/.test(`${r.amount ?? ''} ${r.qty ?? ''} ${r.qty2 ?? ''}`))
+            return true;
+    }
+    return false;
+}
+
+function entriesEqual(curRows, nextEntries) {
+    if (curRows.length !== nextEntries.length)
+        return false;
+    for (let i = 0; i < curRows.length; i++) {
+        const a = curRows[i], b = nextEntries[i];
+        if (a.rule !== b.rule || a.row !== b.row || a.debit_cid !== b.debit_cid || a.credit_cid !== b.credit_cid)
+            return false;
+        if (a.amount !== b.amount || Math.abs((a.qty || 0) - (b.qty || 0)) > 1e-6 || Math.abs((a.qty2 || 0) - (b.qty2 || 0)) > 1e-6)
+            return false;
+    }
+    return true;
+}
+
+/**
+ * Пересчитать через сторно последующие зарегистрированные операции, зависящие от `unit_cost(...)`
+ * по затронутым номенклатурам, если приход/расход был проведён, исправлен или отменён задним числом.
+ */
+function repostDependentOperations(db, triggerOpId, minTime, itemIds, author, now) {
+    if (!itemIds || !itemIds.size || !Number.isFinite(minTime))
+        return 0;
+    const items = [...itemIds];
+    const marks = items.map(() => '?').join(',');
+    const rows = db.prepare(`SELECT DISTINCT o.id, o.time, o.created
+        FROM objects o
+        JOIN entries e ON e.op_id = o.id AND e.storno = 0
+        JOIN entry_analytics a ON a.entry_id = e.id AND a.slot = 'item' AND a.ref_id IN (${marks})
+        WHERE o.status = 'registered' AND o.id <> ? AND o.time >= ?
+        ORDER BY o.time ASC, o.created ASC, o.id ASC`).all(...items, String(triggerOpId), minTime);
+    if (!rows.length)
+        return 0;
+    const candidates = [];
+    for (const r of rows) {
+        if (isClosed(db, r.time))
+            continue;
+        const { op, schema } = mustOperation(db, r.id);
+        if (schemaUsesUnitCost(schema))
+            candidates.push({ op, schema });
+    }
+    if (!candidates.length)
+        return 0;
+    let reposted = 0;
+    for (let i = 0; i < candidates.length; i++) {
+        const { op, schema } = candidates[i];
+        const excludeIds = candidates.slice(i).map(c => c.op.id);
+        const { entries: nextEntries, errors } = computeEntries(db, schema, op, { excludeIds });
+        if (errors.length)
+            continue;
+        const curRows = effectiveRows(db, op.id);
+        if (entriesEqual(curRows, nextEntries))
+            continue;
+        const depNext = writeVersion(db, op.id, { author: author ?? op.author, system: true, force: true });
+        stornoEntries(db, depNext, depNext.version, author ?? op.author, now);
+        insertEntries(db, depNext, nextEntries, { time: depNext.time, version: depNext.version, author: author ?? op.author, now });
+        reposted++;
+    }
+    return reposted;
+}
+
+/* ---------- жизненный цикл ---------- */
+
+function mustOperation(db, id) {
+    const op = readObject(db, id);
+    if (!op)
+        throw new DataError(`операция ${id} не найдена`);
+    const schema = classSchema(db, op.cid);
+    if (schema.family !== 'operation')
+        throw new DataError(`«${op.title || id}» — не операция (${schema.label})`);
+    return { op, schema };
+}
+
+const opName = op => `«${op.title || op.id}»`;
+
+function postOrFail(db, schema, op) {
+    const { entries, errors } = computeEntries(db, schema, op);
+    if (errors.length)
+        throw new DataError(`${opName(op)}: проводки не сформированы`, errors);
+    return entries;
+}
+
+/**
+ * Зарегистрировать черновик: проводки создаются в той же транзакции.
+ * Повторная регистрация зарегистрированной операции ничего не меняет.
+ * @param {object} p { id, author?, version? — ожидаемая версия }
+ */
+export function registerOperation(db, { id, author, version } = {}) {
+    const { op, schema } = mustOperation(db, id);
+    if (op.status === 'registered')
+        return op;
+    if (op.status !== 'draft' && op.status !== 'cancelled')
+        throw new DataError(`операция ${opName(op)} в статусе ${op.status} — регистрируется только черновик`);
+    if (isClosed(db, op.time))
+        throw closedError(db, `регистрировать операцию от ${localDay(op.time)} нельзя`);
+    assertRules(db, schema);
+    return tx(db, () => {
+        const now = Date.now();
+        const entries = postOrFail(db, schema, op);
+        const next = writeVersion(db, op.id, { status: 'registered', author, version, system: true });
+        insertEntries(db, next, entries, { time: next.time, version: next.version, author, now });
+        repostDependentOperations(db, next.id, next.time, collectItemIds(entries), author, now);
+        return next;
+    });
+}
+
+/**
+ * Исправить зарегистрированную операцию: новая версия, сторно прежних проводок
+ * и новые проводки — одной транзакцией. Без изменений — ничего не происходит.
+ * @param {object} p { id, body — изменяемые поля (null — очистить), replace?, time?, author?, version? }
+ */
+export function correctOperation(db, p = {}) {
+    const { op, schema } = mustOperation(db, p.id);
+    if (op.status === 'draft')
+        throw new DataError(`операция ${opName(op)} — черновик: её правят обычным изменением`);
+    if (op.status !== 'registered')
+        throw new DataError(`операция ${opName(op)} в статусе ${op.status} — исправляется только зарегистрированная`);
+    const time = isEmpty(p.time) ? op.time : parseTime(p.time, 'дата операции');
+    if (time !== op.time && isClosed(db, time))
+        throw closedError(db, `перенести операцию на ${localDay(time)} нельзя`);
+    assertRules(db, schema);
+    return tx(db, () => {
+        const prevRows = effectiveRows(db, op.id);
+        const next = writeVersion(db, op.id, { body: mergeBody(op.body, p), time, author: p.author, version: p.version, system: true });
+        if (next.version === op.version)
+            return op;
+        const now = Date.now();
+        const entries = postOrFail(db, schema, next);
+        stornoEntries(db, next, next.version, p.author, now);
+        const entryTime = isClosed(db, next.time) ? now : next.time;
+        insertEntries(db, next, entries, { time: entryTime, version: next.version, author: p.author, now });
+        const affectedItems = new Set([...collectItemIds(prevRows), ...collectItemIds(entries)]);
+        const minTime = Math.min(op.time, entryTime);
+        repostDependentOperations(db, next.id, minTime, affectedItems, p.author, now);
+        return next;
+    });
+}
+
+/**
+ * Отменить зарегистрированную операцию: сторно всех действующих проводок.
+ * @param {object} p { id, author?, version? }
+ */
+export function cancelOperation(db, { id, author, version } = {}) {
+    const { op } = mustOperation(db, id);
+    if (op.status === 'cancelled')
+        return op;
+    if (op.status !== 'registered')
+        throw new DataError(`операция ${opName(op)} в статусе ${op.status} — отменяется только зарегистрированная (черновик удаляют)`);
+    return tx(db, () => {
+        const now = Date.now();
+        const prevRows = effectiveRows(db, op.id);
+        const next = writeVersion(db, op.id, { status: 'cancelled', author, version, system: true });
+        stornoEntries(db, next, next.version, author, now);
+        if (!isClosed(db, op.time))
+            repostDependentOperations(db, next.id, op.time, collectItemIds(prevRows), author, now);
+        return next;
+    });
+}
+
+/**
+ * Проводки, которые дала бы операция, без записи: существующая (`id`) или
+ * несохранённая (`cid`, `body`, `time`). Для формы и ИИ: показать результат до регистрации.
+ * @returns {{ entries: object[], errors: Array<{field, message}> }} amount — в рублях
+ */
+export function previewEntries(db, p = {}) {
+    let op, schema;
+    if (!isEmpty(p.id))
+        ({ op, schema } = mustOperation(db, p.id));
+    else {
+        schema = classSchema(db, p.cid);
+        if (!schema || schema.family !== 'operation')
+            throw new DataError(`класс операции ${p.cid} не найден`);
+        const time = isEmpty(p.time) ? Date.now() : parseTime(p.time, 'дата операции');
+        op = { id: '', cid: schema.cid, time, body: validateBody(db, schema, p.body ?? {}) };
+    }
+    assertRules(db, schema);
+    const { entries, errors } = computeEntries(db, schema, op);
+    return { entries: entries.map(e => presentEntry({ ...e, time: op.time, storno: 0 })), errors };
+}
+
+/** Проводка для показа: amount — в рублях, аналитики сторон — { слот: id }. */
+export function presentEntry(e) {
+    const side = a => Object.fromEntries(Object.entries(a).map(([slot, v]) => [slot, v.ref_id]));
+    return {
+        ...(e.id !== undefined ? { id: e.id, op_id: e.op_id, op_version: e.op_version, op_cid: e.op_cid } : {}),
+        rule: e.rule,
+        row: e.row,
+        time: e.time,
+        debit: e.debit_cid,
+        credit: e.credit_cid,
+        amount: e.amount / 100,
+        qty: e.qty,
+        qty2: e.qty2,
+        doc_qty: e.doc_qty,
+        doc_unit: e.doc_unit,
+        debit_analytics: side(e.analytics.D),
+        credit_analytics: side(e.analytics.C),
+        ...(e.id !== undefined ? { author: e.author, place: e.place, unit: e.unit } : {}),
+        storno: !!e.storno,
+    };
+}
+
+/**
+ * Проводки операции (amount — в рублях).
+ * @param {object} [opts] { history — все проводки всех версий, включая сторно; иначе — действующие }
+ */
+export function operationEntries(db, id, { history = false } = {}) {
+    const { op } = mustOperation(db, id);
+    if (!history)
+        return op.status === 'registered' ? effectiveRows(db, op.id).map(presentEntry) : [];
+    return db.prepare('SELECT * FROM entries WHERE op_id = ? ORDER BY id').all(op.id)
+        .map(r => presentEntry({ ...r, analytics: analyticsOf(db, r.id) }));
+}