letopis 0.5.0 → 0.13.0

package/dist/acl.d.ts

@@ -0,0 +1,48 @@
+/**
+ * ACL по таблицам Resource/Rule. Pattern каждой категории — шаблон «своей» сущности:
+ *
+ *   category='ACCOUNT' — шаблон Account: {"categories": "{A,B}"} — есть любая;
+ *     "!{A,B}" — нет ни одной; NULL — все аккаунты. Субъекты правил.
+ *   category='API'     — шаблон адреса эндпоинта: {"endpoint": "v2.auth.apikey.*"};
+ *     маска: '.'-сегменты, '{a,b}' — альтернативы (вложенные ок), '*' — хвост 1+ сегментов.
+ *   category='READ' | 'WRITE' | 'DELETE' — ШАБЛОН СТРОКИ Entity (операция = категория):
+ *     ключи — реальные колонки (class, owner, account, tags, data, links, id, partition),
+ *     значения — литералы или "$account" (id текущего аккаунта, подставляется в запрос).
+ *     "class" — маска с lineage (класс или любой его предок); нет ключа/NULL — все строки.
+ *     Остальные ключи победившего allow-правила вливаются в SQL ДО сортировки и лимита —
+ *     пагинация/count/keyset работают по уже суженному множеству.
+ *
+ * Rule(субъект-alias → объект-alias, permission allow|deny, weight): правила никогда не
+ * указывают на конкретный аккаунт — принадлежность группе вычисляется из categories.
+ * Побеждает РОВНО ОДНО правило: max weight; при равном весе deny бьёт allow (равные
+ * allow — детерминированно по alias ресурса); НЕТ правил — deny (deny-by-default).
+ */
+import type { AclOp, AclDecision, ClassDef, Resource, Rule } from './types.js';
+import type { Registry } from './schema.js';
+import type { Tables } from './tables.js';
+export declare const ACL_OPS: readonly AclOp[];
+/** pattern.categories: "{A,B}" | "!{A,B}" | отсутствие/NULL (матч всех). */
+export declare function matchCategories(pattern: Record<string, unknown> | null, cats: string[]): boolean;
+export declare function matchMask(mask: string, value: string): boolean;
+export interface AclApi {
+    /** Может ли аккаунт дёрнуть эндпоинт (Resource category='API'). */
+    check(account: string | {
+        id: string;
+    }, endpoint: string): Promise<AclDecision>;
+    /** Решение операции над классом: allow + остаточный шаблон строк (filter) | deny. */
+    checkData(account: string | {
+        id: string;
+    }, className: string, op: AclOp): Promise<AclDecision>;
+    /** Сбросить кэш Resource/Rule фасада (enforceAcl-цепочки перечитывают только новым connect). */
+    reload(): void;
+}
+interface AclSource {
+    resources: Resource[];
+    rules: Rule[];
+}
+export declare function makeAcl(tables: Tables, registry: Registry): AclApi;
+/** Синхронный резолвер для цепочек: категории субъекта и правила зафиксированы на connect. */
+export declare function compileEnforcer(src: AclSource, account: string, cats: string[], registry: Registry): (cls: ClassDef, op: AclOp) => AclDecision;
+/** Читаемая ошибка отказа для цепочек. */
+export declare function aclDenied(op: AclOp, clsId: string, d: AclDecision): Error;
+export {};

package/dist/acl.js

@@ -0,0 +1,208 @@
+export const ACL_OPS = ['READ', 'WRITE', 'DELETE'];
+// --- матчеры -----------------------------------------------------------------
+/** pattern.categories: "{A,B}" | "!{A,B}" | отсутствие/NULL (матч всех). */
+export function matchCategories(pattern, cats) {
+    const spec = pattern?.categories;
+    if (typeof spec !== 'string')
+        return true;
+    const neg = spec.startsWith('!');
+    const list = spec
+        .replace(/^!/, '')
+        .replace(/^\{/, '')
+        .replace(/\}$/, '')
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+    const hit = list.some((c) => cats.includes(c));
+    return neg ? !hit : hit;
+}
+/** Маска → regex: '{a,b}' — альтернативы (рекурсивно), '*' — хвост из 1+ сегментов. */
+function maskBody(mask) {
+    let out = '';
+    for (let i = 0; i < mask.length; i++) {
+        const ch = mask[i];
+        if (ch === '{') {
+            let depth = 1;
+            let j = i + 1;
+            for (; j < mask.length && depth; j++) {
+                if (mask[j] === '{')
+                    depth++;
+                else if (mask[j] === '}')
+                    depth--;
+            }
+            const inner = mask.slice(i + 1, j - 1);
+            const parts = [];
+            let d = 0;
+            let start = 0;
+            for (let k = 0; k <= inner.length; k++) {
+                const c = inner[k];
+                if (k === inner.length || (c === ',' && d === 0)) {
+                    parts.push(inner.slice(start, k));
+                    start = k + 1;
+                }
+                else if (c === '{')
+                    d++;
+                else if (c === '}')
+                    d--;
+            }
+            out += '(?:' + parts.map(maskBody).join('|') + ')';
+            i = j - 1;
+        }
+        else if (ch === '*') {
+            out += '[^.]+(?:\\.[^.]+)*';
+        }
+        else if ('.\\+?()[]^$|'.includes(ch)) {
+            out += '\\' + ch;
+        }
+        else {
+            out += ch;
+        }
+    }
+    return out;
+}
+const regexCache = new Map();
+export function matchMask(mask, value) {
+    let re = regexCache.get(mask);
+    if (!re) {
+        re = new RegExp(`^${maskBody(mask)}$`);
+        regexCache.set(mask, re);
+    }
+    return re.test(value);
+}
+// --- резолюция ----------------------------------------------------------------
+/** Все имена, под которыми класс виден правилам: id+алиас его самого и каждого предка. */
+function classNames(cls, registry) {
+    const names = [];
+    for (const id of cls.ancestors) {
+        names.push(id);
+        try {
+            const a = registry.resolve(id).alias;
+            if (a && a !== id)
+                names.push(a);
+        }
+        catch {
+            /* предок вне реестра — пропуск */
+        }
+    }
+    return names;
+}
+const matchesApi = (r, endpoint) => {
+    if (r.category !== 'API')
+        return false;
+    if (r.pattern == null)
+        return true;
+    const m = r.pattern.endpoint;
+    return typeof m === 'string' && matchMask(m, endpoint);
+};
+/** Ресурс операции op применим к классу? (class-ключ — маска с lineage; нет ключа — все). */
+const matchesRow = (r, op, names) => {
+    if (r.category !== op)
+        return false;
+    if (r.pattern == null)
+        return true;
+    const clsMask = r.pattern.class;
+    return typeof clsMask !== 'string' || names.some((n) => matchMask(clsMask, n));
+};
+/** "$account" → id субъекта, рекурсивно по значениям шаблона. */
+function substitute(v, account) {
+    if (v === '$account')
+        return account;
+    if (Array.isArray(v))
+        return v.map((x) => substitute(x, account));
+    if (v && typeof v === 'object') {
+        return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, substitute(x, account)]));
+    }
+    return v;
+}
+/** Остаточный шаблон строки победившего allow: все ключи, кроме class, с подстановкой. */
+function rowFilter(r, account) {
+    if (r.pattern == null)
+        return undefined;
+    const rest = Object.entries(r.pattern).filter(([k]) => k !== 'class');
+    if (!rest.length)
+        return undefined;
+    return Object.fromEntries(rest.map(([k, v]) => [k, substitute(v, account)]));
+}
+/** Победитель: max weight; равный вес — deny бьёт allow, равные allow — по alias объекта. */
+function decide(rules, subjects, objects) {
+    let winner;
+    for (const rule of rules) {
+        if (!rule.enabled || !subjects.has(rule.account) || !objects.has(rule.resource))
+            continue;
+        if (!winner) {
+            winner = rule;
+            continue;
+        }
+        const w = rule.weight ?? 0;
+        const ww = winner.weight ?? 0;
+        if (w > ww ||
+            (w === ww && winner.permission === 'allow' && rule.permission !== 'allow') ||
+            (w === ww && winner.permission === rule.permission && rule.resource < winner.resource)) {
+            winner = rule;
+        }
+    }
+    return { winner };
+}
+function toDecision(winner, objects, account) {
+    if (!winner)
+        return { allow: false, message: 'no matching rule (deny by default)' };
+    if (winner.permission !== 'allow') {
+        const meta = (winner.meta ?? {});
+        return { allow: false, rule: winner, code: meta.code, message: meta.message };
+    }
+    const res = objects.get(winner.resource);
+    // остаточный шаблон строк — только у ресурсов-операций (у API pattern — не строки Entity)
+    const filter = ACL_OPS.includes(res.category) ? rowFilter(res, account) : undefined;
+    return filter ? { allow: true, rule: winner, filter } : { allow: true, rule: winner };
+}
+const subjectAliases = (resources, cats) => new Set(resources.filter((r) => r.category === 'ACCOUNT' && matchCategories(r.pattern, cats)).map((r) => r.alias));
+const toMap = (rs) => new Map(rs.map((r) => [r.alias, r]));
+const accId = (a) => (typeof a === 'object' ? a.id : a);
+export function makeAcl(tables, registry) {
+    let cache = null;
+    const load = () => (cache ??= (async () => ({
+        resources: await tables.resources.find(),
+        rules: await tables.rules.find({ enabled: true }),
+    }))());
+    const catsOf = async (account) => (await tables.accounts.get(accId(account)))?.categories ?? [];
+    return {
+        async check(account, endpoint) {
+            const [{ resources, rules }, cats] = await Promise.all([load(), catsOf(account)]);
+            const objects = toMap(resources.filter((r) => matchesApi(r, endpoint)));
+            const { winner } = decide(rules, subjectAliases(resources, cats), objects);
+            return toDecision(winner, objects, accId(account));
+        },
+        async checkData(account, className, op) {
+            const [{ resources, rules }, cats] = await Promise.all([load(), catsOf(account)]);
+            const names = classNames(registry.resolve(className), registry);
+            const objects = toMap(resources.filter((r) => matchesRow(r, op, names)));
+            const { winner } = decide(rules, subjectAliases(resources, cats), objects);
+            return toDecision(winner, objects, accId(account));
+        },
+        reload() {
+            cache = null;
+        },
+    };
+}
+// --- enforce-компилятор (connect({enforceAcl: true})) ----------------------------
+/** Синхронный резолвер для цепочек: категории субъекта и правила зафиксированы на connect. */
+export function compileEnforcer(src, account, cats, registry) {
+    const subjects = subjectAliases(src.resources, cats);
+    const memo = new Map();
+    return (cls, op) => {
+        const key = `${cls.id} ${op}`;
+        let d = memo.get(key);
+        if (!d) {
+            const names = classNames(cls, registry);
+            const objects = toMap(src.resources.filter((r) => matchesRow(r, op, names)));
+            const { winner } = decide(src.rules, subjects, objects);
+            d = toDecision(winner, objects, account);
+            memo.set(key, d);
+        }
+        return d;
+    };
+}
+/** Читаемая ошибка отказа для цепочек. */
+export function aclDenied(op, clsId, d) {
+    return new Error(`letopis: acl denies ${op} on ${clsId}${d.message ? ` — ${d.message}` : ''}`);
+}

package/dist/auth.d.ts

@@ -0,0 +1,116 @@
+import type { Account, Credential } from './types.js';
+import type { Tables } from './tables.js';
+import { type SessionStore, type Sessions } from './sessions.js';
+/** Код authenticator-а для секрета на момент времени (хелпер для тестов/сервисов). */
+export declare function totpCode(secretBase32: string, atMs?: number): string;
+/** Успешный вход: чей кред и какой именно. */
+export interface AuthResult {
+    account: Account;
+    credential: Credential;
+}
+interface VerifyOpts {
+    /** false — пускать и неподтверждённые креды (default: подтверждённые). */
+    requireConfirmed?: boolean;
+}
+export interface AuthApi {
+    /** Пароль (upsert): логин/пароль и почта/пароль — одна механика, различает category. */
+    setPassword(a: {
+        account: string | {
+            id: string;
+        };
+        identifier: string;
+        password: string;
+        category?: string;
+        confirmed?: boolean;
+    }): Promise<Credential>;
+    verifyPassword(a: {
+        identifier: string;
+        password: string;
+        category?: string;
+    } & VerifyOpts): Promise<AuthResult | null>;
+    /** Новый api-ключ `lts_<48hex>`: отдаётся ОДИН раз, в БД — только sha256. */
+    issueApiKey(a: {
+        account: string | {
+            id: string;
+        };
+        name?: string;
+    }): Promise<{
+        key: string;
+        credential: Credential;
+    }>;
+    verifyApiKey(key: string, opts?: VerifyOpts): Promise<AuthResult | null>;
+    /** Пара key(открытый id)+secret: secret отдаётся один раз, в БД — sha256. */
+    issueKeySecret(a: {
+        account: string | {
+            id: string;
+        };
+        name?: string;
+    }): Promise<{
+        key: string;
+        secret: string;
+        credential: Credential;
+    }>;
+    verifyKeySecret(key: string, secret: string, opts?: VerifyOpts): Promise<AuthResult | null>;
+    /** TOTP (authenticator): секрет + otpauth-URI для QR; активен после первой успешной проверки. */
+    enrollTotp(a: {
+        account: string | {
+            id: string;
+        };
+        issuer?: string;
+        label?: string;
+    }): Promise<{
+        secret: string;
+        uri: string;
+        credential: Credential;
+    }>;
+    /** Проверка 6-значного кода: окно ±window шагов (default 1), replay того же шага отбит. */
+    verifyTotp(a: {
+        account: string | {
+            id: string;
+        };
+        code: string;
+        window?: number;
+    }): Promise<boolean>;
+    /** true — TOTP-фактор включён (enroll подтверждён хотя бы одной проверкой). */
+    totpEnabled(account: string | {
+        id: string;
+    }): Promise<boolean>;
+    /** Одноразовый код (email/SMS/reset — доставка на приложении): в БД sha256 + TTL + лимит попыток. */
+    issueOtp(a: {
+        account: string | {
+            id: string;
+        };
+        identifier: string;
+        category?: string;
+        ttlSec?: number;
+        digits?: number;
+    }): Promise<{
+        code: string;
+        credential: Credential;
+    }>;
+    /** Успех сжигает код (одноразовость); maxAttempts (default 5) неудач тоже сжигают. */
+    verifyOtp(a: {
+        identifier: string;
+        code: string;
+        category?: string;
+        maxAttempts?: number;
+    }): Promise<AuthResult | null>;
+    /** Внешняя identity (TELEGRAM / GOOGLE / SSO-провайдер…): токен проверяет приложение, тут — связка. */
+    link(a: {
+        account: string | {
+            id: string;
+        };
+        category: string;
+        identifier: string;
+        meta?: Record<string, unknown>;
+        confirmed?: boolean;
+    }): Promise<Credential>;
+    lookup(a: {
+        category: string;
+        identifier: string;
+    } & VerifyOpts): Promise<AuthResult | null>;
+    /** Сессии во внешнем KV (Redis): store инжектирует приложение. */
+    sessions(store: SessionStore): Sessions;
+}
+export declare function makeAuth(tables: Tables): AuthApi;
+export {};

package/dist/auth.js

@@ -0,0 +1,263 @@
+/**
+ * db.auth: вход по таблице Credential — на аккаунт много способов:
+ * пароль (логин/почта), api-ключ, ключ-секрет, внешние identity (oauth/sso/telegram).
+ * Пароли — scrypt (node:crypto, без зависимостей); ключи/секреты — в БД только sha256.
+ * Однозначность входа даёт credential_identity_udx: один живой кред на (category, identifier).
+ * OAuth-танец, rate-limit, lockout — на приложении: здесь хранение и проверка.
+ */
+import { createHash, createHmac, randomBytes, randomInt, scrypt, timingSafeEqual } from 'node:crypto';
+import { promisify } from 'node:util';
+import { makeSessions } from './sessions.js';
+const scryptAsync = promisify(scrypt);
+// OWASP-порядок стойкости; maxmem с запасом (128*N*r байт впритык к дефолтным 32MiB)
+const SCRYPT = { N: 32768, r: 8, p: 1, maxmem: 64 * 1024 * 1024 };
+const KEYLEN = 32;
+const sha256 = (s) => createHash('sha256').update(s).digest('hex');
+async function hashPassword(password) {
+    const salt = randomBytes(16);
+    const hash = await scryptAsync(password, salt, KEYLEN, SCRYPT);
+    return `scrypt$${SCRYPT.N}$${SCRYPT.r}$${SCRYPT.p}$${salt.toString('base64')}$${hash.toString('base64')}`;
+}
+async function verifyHash(password, stored) {
+    const [algo, N, r, p, saltB64, hashB64] = stored.split('$');
+    if (algo !== 'scrypt')
+        return false; // legacy-форматы (bcrypt из дампа) не верифицируем
+    const want = Buffer.from(hashB64, 'base64');
+    const got = await scryptAsync(password, Buffer.from(saltB64, 'base64'), want.length, {
+        N: Number(N), r: Number(r), p: Number(p), maxmem: SCRYPT.maxmem,
+    });
+    return timingSafeEqual(got, want);
+}
+/** Выравнивание времени ответа: «identifier не существует» не быстрее «пароль неверен». */
+const dummyVerify = (password) => scryptAsync(password, Buffer.alloc(16), KEYLEN, SCRYPT).then(() => false);
+const eqHex = (a, b) => {
+    const ba = Buffer.from(a, 'hex');
+    const bb = Buffer.from(b, 'hex');
+    return ba.length === bb.length && timingSafeEqual(ba, bb);
+};
+const eqStr = (a, b) => {
+    const ba = Buffer.from(a);
+    const bb = Buffer.from(b);
+    return ba.length === bb.length && timingSafeEqual(ba, bb);
+};
+// --- TOTP (RFC 6238 / HOTP RFC 4226) ---------------------------------------
+const B32 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
+function base32Encode(buf) {
+    let bits = 0;
+    let value = 0;
+    let out = '';
+    for (const byte of buf) {
+        value = (value << 8) | byte;
+        bits += 8;
+        while (bits >= 5) {
+            out += B32[(value >>> (bits - 5)) & 31];
+            bits -= 5;
+        }
+    }
+    if (bits > 0)
+        out += B32[(value << (5 - bits)) & 31];
+    return out;
+}
+function base32Decode(s) {
+    let bits = 0;
+    let value = 0;
+    const out = [];
+    for (const ch of s.replace(/=+$/, '').toUpperCase()) {
+        const idx = B32.indexOf(ch);
+        if (idx < 0)
+            throw new Error('letopis: invalid base32 TOTP secret');
+        value = (value << 5) | idx;
+        bits += 5;
+        if (bits >= 8) {
+            out.push((value >>> (bits - 8)) & 255);
+            bits -= 8;
+        }
+    }
+    return Buffer.from(out);
+}
+const TOTP_PERIOD = 30; // секунд на шаг (стандарт authenticator-приложений)
+const TOTP_DIGITS = 6;
+function hotp(secret, counter) {
+    const buf = Buffer.alloc(8);
+    buf.writeBigUInt64BE(BigInt(counter));
+    const h = createHmac('sha1', secret).update(buf).digest();
+    const off = h[h.length - 1] & 0xf;
+    const code = (((h[off] & 0x7f) << 24) | (h[off + 1] << 16) | (h[off + 2] << 8) | h[off + 3]) % 10 ** TOTP_DIGITS;
+    return String(code).padStart(TOTP_DIGITS, '0');
+}
+const totpStep = (atMs) => Math.floor(atMs / 1000 / TOTP_PERIOD);
+/** Код authenticator-а для секрета на момент времени (хелпер для тестов/сервисов). */
+export function totpCode(secretBase32, atMs = Date.now()) {
+    return hotp(base32Decode(secretBase32), totpStep(atMs));
+}
+// ---------------------------------------------------------------------------
+const accId = (a) => (typeof a === 'object' ? a.id : a);
+export function makeAuth(tables) {
+    /** Живой кред по глобально-уникальной паре (category, identifier). */
+    const findLive = async (category, identifier) => (await tables.credentials.find({ category, identifier }))[0] ?? null;
+    /** Общие ворота: confirmed-кред + enabled-аккаунт. */
+    async function finalize(cred, opts) {
+        if (!cred.confirmed && opts.requireConfirmed !== false)
+            return null;
+        const account = await tables.accounts.get(cred.account);
+        if (!account?.enabled)
+            return null;
+        return { account, credential: cred };
+    }
+    return {
+        async setPassword(a) {
+            return tables.credentials.set({
+                account: accId(a.account),
+                category: a.category ?? 'PASSWORD',
+                identifier: a.identifier,
+                meta: { password: await hashPassword(a.password) },
+                confirmed: a.confirmed,
+            });
+        },
+        async verifyPassword(a) {
+            const cred = await findLive(a.category ?? 'PASSWORD', a.identifier);
+            const stored = cred?.meta.password;
+            if (!cred || typeof stored !== 'string') {
+                await dummyVerify(a.password);
+                return null;
+            }
+            if (!(await verifyHash(a.password, stored)))
+                return null;
+            return finalize(cred, a);
+        },
+        async issueApiKey(a) {
+            const key = `lts_${randomBytes(24).toString('hex')}`;
+            const credential = await tables.credentials.set({
+                account: accId(a.account),
+                category: 'APIKEY',
+                identifier: sha256(key),
+                meta: { name: a.name ?? null, prefix: key.slice(0, 12) },
+            });
+            return { key, credential };
+        },
+        async verifyApiKey(key, opts = {}) {
+            const cred = await findLive('APIKEY', sha256(key));
+            return cred ? finalize(cred, opts) : null;
+        },
+        async issueKeySecret(a) {
+            const key = randomBytes(8).toString('hex');
+            const secret = randomBytes(24).toString('hex');
+            const credential = await tables.credentials.set({
+                account: accId(a.account),
+                category: 'KEYSECRET',
+                identifier: key,
+                meta: { name: a.name ?? null, secret: sha256(secret) },
+            });
+            return { key, secret, credential };
+        },
+        async verifyKeySecret(key, secret, opts = {}) {
+            const cred = await findLive('KEYSECRET', key);
+            const stored = cred?.meta.secret;
+            if (!cred || typeof stored !== 'string' || !eqHex(sha256(secret), stored))
+                return null;
+            return finalize(cred, opts);
+        },
+        async enrollTotp(a) {
+            const id = accId(a.account);
+            const secret = base32Encode(randomBytes(20));
+            const label = encodeURIComponent(a.label ?? id);
+            const issuer = a.issuer ? `&issuer=${encodeURIComponent(a.issuer)}` : '';
+            const uri = `otpauth://totp/${label}?secret=${secret}${issuer}` +
+                `&algorithm=SHA1&digits=${TOTP_DIGITS}&period=${TOTP_PERIOD}`;
+            // re-enroll перезаписывает секрет и сбрасывает подтверждение
+            const credential = await tables.credentials.set({
+                account: id,
+                category: 'TOTP',
+                identifier: id, // один TOTP-фактор на аккаунт
+                meta: { secret, lastStep: 0 },
+                confirmed: false,
+            });
+            return { secret, uri, credential };
+        },
+        async verifyTotp(a) {
+            const id = accId(a.account);
+            const cred = (await tables.credentials.find({ account: id, category: 'TOTP' }))[0];
+            const secretB32 = cred?.meta.secret;
+            if (!cred || typeof secretB32 !== 'string')
+                return false;
+            const secret = base32Decode(secretB32);
+            const lastStep = typeof cred.meta.lastStep === 'number' ? cred.meta.lastStep : 0;
+            const now = totpStep(Date.now());
+            const window = a.window ?? 1;
+            for (let s = now - window; s <= now + window; s++) {
+                if (s <= lastStep)
+                    continue; // replay: шаг уже использован
+                if (!eqStr(a.code, hotp(secret, s)))
+                    continue;
+                await tables.credentials.set({
+                    account: id,
+                    category: 'TOTP',
+                    identifier: cred.identifier,
+                    meta: { ...cred.meta, lastStep: s },
+                    confirmed: true, // первая успешная проверка активирует фактор
+                });
+                return true;
+            }
+            return false;
+        },
+        async totpEnabled(account) {
+            const cred = (await tables.credentials.find({ account: accId(account), category: 'TOTP' }))[0];
+            return cred?.confirmed === true;
+        },
+        async issueOtp(a) {
+            const digits = a.digits ?? 6;
+            const code = String(randomInt(0, 10 ** digits)).padStart(digits, '0');
+            // повторный issue на тот же identifier перезаписывает код (валиден только последний)
+            const credential = await tables.credentials.set({
+                account: accId(a.account),
+                category: a.category ?? 'OTP',
+                identifier: a.identifier,
+                meta: {
+                    code: sha256(code),
+                    expires: new Date(Date.now() + (a.ttlSec ?? 600) * 1000).toISOString(),
+                    attempts: 0,
+                },
+            });
+            return { code, credential };
+        },
+        async verifyOtp(a) {
+            const cred = await findLive(a.category ?? 'OTP', a.identifier);
+            if (!cred)
+                return null;
+            const { code, expires, attempts } = cred.meta;
+            if (typeof code !== 'string' || !expires || Date.parse(expires) < Date.now()) {
+                await tables.credentials.delete(cred.id);
+                return null;
+            }
+            if (!eqHex(sha256(a.code), code)) {
+                const n = (attempts ?? 0) + 1;
+                if (n >= (a.maxAttempts ?? 5))
+                    await tables.credentials.delete(cred.id); // перебор — код сожжён
+                else
+                    await tables.credentials.set({
+                        account: cred.account,
+                        category: cred.category,
+                        identifier: cred.identifier,
+                        meta: { ...cred.meta, attempts: n },
+                    });
+                return null;
+            }
+            await tables.credentials.delete(cred.id); // одноразовость: успех сжигает код
+            return finalize(cred, {});
+        },
+        async link(a) {
+            return tables.credentials.set({
+                account: accId(a.account),
+                category: a.category,
+                identifier: a.identifier,
+                meta: a.meta ?? {},
+                confirmed: a.confirmed,
+            });
+        },
+        async lookup(a) {
+            const cred = await findLive(a.category, a.identifier);
+            return cred ? finalize(cred, a) : null;
+        },
+        sessions: makeSessions,
+    };
+}