letopis 0.18.0 → 0.19.0

package/dist/index.js

@@ -60,8 +60,10 @@ export async function connect(opts) {
         slowMs: opts.slowMs,
     };
     // START_BLOCK_ENFORCE_ACL
-    // enforceAcl: правила и категории субъекта фиксируются на connect (перечитка — новый connect)
-    if (opts.enforceAcl) {
+    // enforceAcl: правила и категории субъекта компилятся в резолвер (перечитываются reloadSchema/reload)
+    const compileAcl = async () => {
+        if (!opts.enforceAcl)
+            return;
         if (!opts.account)
             throw new Error('letopis: enforceAcl requires connect({ account })');
         const tables = makeTables(ctx);
@@ -72,8 +74,14 @@ export async function connect(opts) {
         ]);
         if (!account)
             throw new Error(`letopis: enforceAcl — account "${opts.account}" not found`);
-        ctx.aclDecide = compileEnforcer({ resources, rules }, account.id, account.categories, registry);
-    }
+        ctx.aclDecide = compileEnforcer({ resources, rules }, account.id, account.categories, ctx.registry);
+    };
+    await compileAcl();
+    // db.reloadSchema(): перечитать определения классов из таблицы Schema (registry + enforcer) без реконнекта
+    ctx.reload = async () => {
+        ctx.registry = await loadRegistry(sql, opts.schema, partition);
+        await compileAcl();
+    };
     // END_BLOCK_ENFORCE_ACL
     return makeDb(ctx);
 }

package/dist/sql.d.ts

@@ -41,6 +41,8 @@ export interface Ctx {
     onQuery?: (e: QueryEvent) => void;
     /** Порог «медленного» запроса, мс (без onQuery — console.warn). */
     slowMs?: number;
+    /** Перечитать определения классов из таблицы Schema: пересобрать registry (+ enforcer при enforceAcl). Ставит connect(). */
+    reload?: () => Promise<void>;
 }
 /** Транзиентные ошибки PG — гонка, снимаемая повтором: deadlock / serialization failure. */
 export declare function isTransient(e: unknown): boolean;
@@ -131,4 +133,10 @@ export declare function deleteSql(pgSchema: string, n: number): string;
  * Рекурсивный CTE; каждый узел — актуальная живая версия. $1 partition, $2 class, $3+ — ids.
  */
 export declare function closureSql(pgSchema: string, n: number): string;
+/**
+ * Вызов серверной purge(): $4 dry → превью (актуальные версии замыкания, БД цела), иначе двухфазный
+ * физический снос корня+поддерева. RETURNS SETOF Entity (по строке на сущность). Вся логика
+ * (замыкание, двухфазность, отключение триггера через SET LOCAL) — в БД. $1 partition, $2 class, $3 id, $4 dry.
+ */
+export declare function purgeCallSql(pgSchema: string): string;
 export {};

package/dist/sql.js

@@ -517,8 +517,10 @@ export function buildRead(ctx, steps, mods, mode) {
         const innerWhere = [`e.partition = ${pPart}`, `e.class = ${pCls}`];
         if (mods.asOf !== undefined)
             innerWhere.push(`e.updated <= ${p.push(mods.asOf)}::timestamptz`); // «как было на T»
-        // versions: последний шаг включает и удалённые сущности (история существует после delete)
-        const outerWhere = [mode === 'versions' && i === steps.length - 1 ? 'TRUE' : 't.deleted IS NULL'];
+        // versions/.withDeleted(): последний шаг включает и удалённые (история/tombstone видны после delete).
+        // Снимается ТОЛЬКО фильтр deleted — enforceAccount/enforceAcl/контекст-фраги ниже действуют (изоляция цела).
+        const keepDeleted = i === steps.length - 1 && (mode === 'versions' || mods.withDeleted === true);
+        const outerWhere = [keepDeleted ? 'TRUE' : 't.deleted IS NULL'];
         const candWhere = f.candFrags.map((fr) => fr('c'));
         for (const c of f.idConds)
             innerWhere.push(c('e'));
@@ -726,3 +728,18 @@ export function closureSql(pgSchema, n) {
      )
      SELECT DISTINCT ON (class, id) * FROM node ORDER BY class, id, updated DESC`);
 }
+/**
+ * Вызов серверной purge(): $4 dry → превью (актуальные версии замыкания, БД цела), иначе двухфазный
+ * физический снос корня+поддерева. RETURNS SETOF Entity (по строке на сущность). Вся логика
+ * (замыкание, двухфазность, отключение триггера через SET LOCAL) — в БД. $1 partition, $2 class, $3 id, $4 dry.
+ */
+// START_CONTRACT: purgeCallSql
+//   PURPOSE: SQL-обёртка вызова серверной purge() (снос/превью) — вся логика в БД, JS лишь зовёт.
+//   INPUTS: { pgSchema: string }
+//   OUTPUTS: { string - SELECT * FROM "<schema>".purge($1,$2,$3,$4) }
+//   SIDE_EFFECTS: none
+//   LINKS: M-SQL, V-M-SQL, M-DDL, M-WRITE
+// END_CONTRACT: purgeCallSql
+export function purgeCallSql(pgSchema) {
+    return `SELECT * FROM ${escId(pgSchema)}.purge($1, $2, $3, $4)`;
+}

package/dist/tables.d.ts

@@ -17,6 +17,12 @@ export interface AccountsApi {
     set(a: Partial<Account>): Promise<Account>;
     /** Физический DELETE; Credential снесётся FK-каскадом. */
     delete(id: string): Promise<boolean>;
+    /**
+     * Полный физический офбординг тенанта (необратимо): все Entity (account|owner=id) + сам Account
+     * (Credential — FK-каскад), через серверную purge_account(). Предохранители: только Owner/System-вызов;
+     * нельзя снести последний enabled Owner (лок-аут) и свой аккаунт. → true если Account снесён.
+     */
+    purge(id: string): Promise<boolean>;
 }
 export interface CredentialsApi {
     /** deleted IS NULL по умолчанию; withDeleted: true — включая удалённые. */
@@ -72,10 +78,28 @@ export interface RulesApi {
     }): Promise<Rule>;
     delete(account: string, resource: string): Promise<boolean>;
 }
+export interface SchemaApi {
+    /**
+     * Upsert определения класса в таблицу Schema (ON CONFLICT (partition,id) DO UPDATE) + reloadSchema().
+     * Правка «простым SQL», подхватывается сразу без реконнекта. attributes — DSL fastest-validator
+     * (валидирует либа при чтении реестра); ancestors/descendants считает триггер schema_lineage.
+     */
+    define(def: {
+        id: string;
+        alias: string;
+        category: 'HUB' | 'LINK';
+        ancestor?: string | null;
+        attributes?: Record<string, unknown>;
+        meta?: Record<string, unknown>;
+        links?: unknown[];
+        order?: number;
+    }): Promise<void>;
+}
 export interface Tables {
     accounts: AccountsApi;
     credentials: CredentialsApi;
     resources: ResourcesApi;
     rules: RulesApi;
+    schema: SchemaApi;
 }
 export declare function makeTables(ctx: Ctx): Tables;

package/dist/tables.js

@@ -85,6 +85,44 @@ export function makeTables(ctx) {
             const rows = await run(`DELETE FROM ${T(ctx, 'Account')} WHERE id = $1 RETURNING id`, [id]);
             return rows.length > 0;
         },
+        // START_CONTRACT: accounts.purge
+        //   PURPOSE: Физический офбординг тенанта через purge_account(); гарды Owner/System, последний Owner, не-себя — до сноса, в одной tx.
+        //   INPUTS: { id: string - целевой аккаунт }
+        //   OUTPUTS: { Promise<boolean> - true если Account физически снесён }
+        //   SIDE_EFFECTS: физ. DELETE всех Entity аккаунта + Account (Credential FK-каскад) через SQL purge_account()
+        //   ERRORS: нет caller/ACL; вызов не Owner/System; снос последнего Owner; снос своего аккаунта
+        //   LINKS: M-TABLES, V-M-TABLES, M-DDL
+        // END_CONTRACT: accounts.purge
+        async purge(id) {
+            if (!ctx.account) {
+                throw new Error('letopis: accounts.purge requires an authenticated caller — connect({ account })');
+            }
+            if (id === ctx.account) {
+                throw new Error('letopis: accounts.purge cannot purge the calling account itself');
+            }
+            const schema = `"${ctx.pgSchema.replace(/"/g, '""')}"`;
+            return ctx.sql.begin(async (tsql) => {
+                const q = (t, p) => tsql.unsafe(t, p);
+                // вызывающий обязан быть Owner/System
+                const caller = await q(`SELECT categories FROM ${T(ctx, 'Account')} WHERE id = $1`, [ctx.account]);
+                const cats = caller[0]?.categories ?? [];
+                if (!cats.includes('Owner') && !cats.includes('System')) {
+                    throw new Error('letopis: accounts.purge is restricted to Owner/System accounts');
+                }
+                const tgt = await q(`SELECT categories FROM ${T(ctx, 'Account')} WHERE id = $1`, [id]);
+                if (!tgt.length)
+                    return false;
+                // нельзя снести последний enabled Owner → тенант без владельца (лок-аут)
+                if ((tgt[0].categories ?? []).includes('Owner')) {
+                    const cnt = await q(`SELECT count(*)::text AS n FROM ${T(ctx, 'Account')} WHERE 'Owner' = ANY(categories) AND enabled`, []);
+                    if (Number(cnt[0]?.n ?? 0) <= 1) {
+                        throw new Error('letopis: refusing to purge the last enabled Owner (tenant lock-out)');
+                    }
+                }
+                const res = await q(`SELECT ${schema}.purge_account($1::uuid) AS id`, [id]);
+                return res[0]?.id != null;
+            });
+        },
     };
     // END_BLOCK_ACCOUNTS_API
     // START_BLOCK_CREDENTIALS_API
@@ -181,5 +219,22 @@ export function makeTables(ctx) {
         },
     };
     // END_BLOCK_RULES_API
-    return { accounts, credentials, resources, rules };
+    // START_BLOCK_SCHEMA_API
+    const schema = {
+        async define(def) {
+            // jsonb-значения через sql.json() — postgres.js кладёт как jsonb (не PG-массив/строку)
+            const j = (v) => ctx.sql.json(v);
+            await run(`INSERT INTO ${T(ctx, 'Schema')} (partition, id, alias, category, ancestor, attributes, meta, links, "order")
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+         ON CONFLICT (partition, id) DO UPDATE SET
+           alias = EXCLUDED.alias, category = EXCLUDED.category, ancestor = EXCLUDED.ancestor,
+           attributes = EXCLUDED.attributes, meta = EXCLUDED.meta, links = EXCLUDED.links, "order" = EXCLUDED."order"`, [
+                ctx.partition, def.id, def.alias, def.category, def.ancestor ?? null,
+                j(def.attributes ?? {}), j(def.meta ?? {}), j(def.links ?? []), def.order ?? 0,
+            ]);
+            await ctx.reload?.(); // подхватить новое определение сразу (registry + enforcer)
+        },
+    };
+    // END_BLOCK_SCHEMA_API
+    return { accounts, credentials, resources, rules, schema };
 }

package/dist/types.d.ts

@@ -125,12 +125,12 @@ export interface Cursor {
  * Терминал исполняет план (все операции + финальное чтение) одной транзакцией.
  */
 export interface PlanOp {
-    kind: 'create' | 'update' | 'delete' | 'anonymize';
+    kind: 'create' | 'update' | 'delete' | 'anonymize' | 'purge';
     /** create/update: данные новой версии (deep-merge листьев). */
     data?: Record<string, unknown>;
     /** anonymize: string-поля под '[erased]'. */
     fields?: string[];
-    /** delete: true — удалить; без confirm — превью (вернуть кандидатов, БД не трогать). */
+    /** delete/purge: true — выполнить; без confirm — превью (вернуть кандидатов/замыкание, БД не трогать). */
     confirm?: boolean;
     /** Снапшот модификаторов на момент вызова операции (limit/sort для поиска целей). */
     mods: ChainMods;
@@ -149,6 +149,8 @@ export interface ChainMods {
     /** Внутреннее: агрегация терминалов .sum/.avg/.min/.max/.countBy. */
     aggFn?: 'sum' | 'avg' | 'min' | 'max' | 'countBy';
     aggField?: string;
+    /** .withDeleted(): последний шаг включает удалённые (tombstone). Снимает ТОЛЬКО фильтр deleted; enforceAccount/enforceAcl действуют. */
+    withDeleted?: boolean;
 }
 export interface Account {
     id: string;

package/dist/write.d.ts

@@ -56,6 +56,15 @@ export declare function anonymizeOp(ctx: Ctx, steps: Step[], mods: ChainMods, fi
  * Без confirm — ПРЕВЬЮ: то же замыкание (цели + каскад), но БД не трогается.
  */
 export declare function delOp(ctx: Ctx, steps: Step[], mods: ChainMods, confirm: boolean): Promise<Row[]>;
+/**
+ * .purge({confirm}): ФИЗИЧЕСКИЙ hard-erase — сносит логически удалённые цели + всё поддерево (все версии).
+ * Вся логика — в серверной purge() (двухфазность: живую цель не трогает; замыкание по links; SET LOCAL
+ * отключает entity_delete → плоский снос без TM_SelfModified). JS лишь резолвит цели и зовёт функцию.
+ * confirm: false → dry-превью (что сотрётся, БД цела); true → снос, возвращает снесённое ($deleted).
+ * gate: DELETE-право на класс цели (aclWrite) — поддерево уже было DELETE-авторизовано при мягком удалении.
+ * В отличие от .delete() (tombstone, обратимо) — необратимо, историю НЕ сохраняет.
+ */
+export declare function purgeOp(ctx: Ctx, steps: Step[], mods: ChainMods, confirm: boolean): Promise<Row[]>;
 export type PlanMode = 'rows' | 'ids' | 'count' | 'paths' | 'versions' | 'agg';
 /**
  * Исполнить план целиком: все операции + финальное чтение — одна транзакция

package/dist/write.js

@@ -40,7 +40,7 @@
 // END_CHANGE_SUMMARY
 import { randomUUID } from 'node:crypto';
 import { uuidv5, uuidv7 } from './uuid.js';
-import { buildRead, runQuery, insertSql, multiInsertSql, deleteSql, closureSql, isTransient, retryDelay, RETRIES, } from './sql.js';
+import { buildRead, runQuery, insertSql, multiInsertSql, deleteSql, closureSql, purgeCallSql, isTransient, retryDelay, RETRIES, } from './sql.js';
 import { aclDenied } from './acl.js';
 // START_CONTRACT: ValidationError
 //   PURPOSE: Ошибка валидации класса, несущая список проблемных полей (issues).
@@ -581,6 +581,40 @@ export async function delOp(ctx, steps, mods, confirm) {
     });
     // END_BLOCK_DELETE_CASCADE
 }
+/**
+ * .purge({confirm}): ФИЗИЧЕСКИЙ hard-erase — сносит логически удалённые цели + всё поддерево (все версии).
+ * Вся логика — в серверной purge() (двухфазность: живую цель не трогает; замыкание по links; SET LOCAL
+ * отключает entity_delete → плоский снос без TM_SelfModified). JS лишь резолвит цели и зовёт функцию.
+ * confirm: false → dry-превью (что сотрётся, БД цела); true → снос, возвращает снесённое ($deleted).
+ * gate: DELETE-право на класс цели (aclWrite) — поддерево уже было DELETE-авторизовано при мягком удалении.
+ * В отличие от .delete() (tombstone, обратимо) — необратимо, историю НЕ сохраняет.
+ */
+// START_CONTRACT: purgeOp
+//   PURPOSE: .purge({confirm}) — резолв целей (вкл. tombstone) + вызов серверной purge() (снос при confirm, иначе dry-превью).
+//   INPUTS: { ctx: Ctx; steps: Step[]; mods: ChainMods; confirm: boolean }
+//   OUTPUTS: { Promise<Row[]> - снесённое с $deleted, либо dry-превью; [] если цели не tombstone/не найдены }
+//   SIDE_EFFECTS: физический DELETE в Entity через purge() (SET LOCAL letopis.purge отключает триггер)
+//   ERRORS: acl denies DELETE (класс цели)
+//   LINKS: M-WRITE, V-M-WRITE, M-ACL, M-DDL, M-SQL
+// END_CONTRACT: purgeOp
+export async function purgeOp(ctx, steps, mods, confirm) {
+    const target = steps[steps.length - 1];
+    aclWrite(ctx, target, 'DELETE');
+    // цели ищем ВКЛЮЧАЯ tombstone — .purge() работает по уже логически удалённым (двухфазность в purge())
+    const targets = await readRows(ctx, steps, { ...mods, withDeleted: true });
+    if (!targets.length)
+        return [];
+    return inTransaction(ctx, async (c) => {
+        const out = [];
+        // вся логика (двухфазность, замыкание, отключение триггера) — в серверной purge(); dry = !confirm
+        for (const t of targets) {
+            const rows = await runQuery(c, purgeCallSql(c.pgSchema), [c.partition, target.cls.id, t.id, !confirm], 'delete', [target.cls.id]);
+            for (const r of rows)
+                out.push(confirm ? { ...toRow(r), $deleted: true } : toRow(r));
+        }
+        return out;
+    });
+}
 /** Разрезать план: сегменты (…шаги + op-шаг) и читающий хвост после последней операции. */
 function splitPlan(steps) {
     const segments = [];
@@ -604,6 +638,8 @@ function opCall(c, steps, op) {
             return anonymizeOp(c, steps, op.mods, op.fields ?? []);
         case 'delete':
             return delOp(c, steps, op.mods, op.confirm === true);
+        case 'purge':
+            return purgeOp(c, steps, op.mods, op.confirm === true);
     }
 }
 /** Виртуальный старт-шаг «от этих строк»: контекст/чтение следующего сегмента. */
@@ -651,7 +687,8 @@ export async function runPlan(ctx, steps, mods, mode) {
                     last.push(...await opCall(c, rowSteps, seg.op));
                 }
             }
-            start = seg.op.kind === 'delete' ? last.filter((r) => r.class === targetCls.id) : last;
+            start = (seg.op.kind === 'delete' || seg.op.kind === 'purge')
+                ? last.filter((r) => r.class === targetCls.id) : last;
         }
         // END_BLOCK_RUNPLAN_SEGMENTS
         const opStep = segments[segments.length - 1].steps.at(-1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "letopis",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "description": "Letopis (летопись): append-only versioned entity store on TimescaleDB with dot-notation chains — every change is a new row, history is first-class (asOf, versions, watch, cascade tombstones)",
   "keywords": [
     "timescaledb",
@@ -35,6 +35,7 @@
   },
   "files": [
     "dist",
+    "scripts",
     "sql",
     "docker",
     "README.md",

package/scripts/gen-types.mjs

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+/**
+ * Генерация TS-типов из таблицы Schema:
+ *   npx tsx scripts/gen-types.mjs --dsn=postgres://… --schema=v1.booking [--out=entity-types.d.ts]
+ *
+ * Результат: интерфейсы data-полей каждого класса + фасад TypedDb.
+ *   import type { TypedDb } from './entity-types';
+ *   const t = db as unknown as TypedDb;   // t.Сотрудник(...).rows(): Promise<TypedRow<StaffData>[]>
+ */
+//
+// FILE: lib/scripts/gen-types.mjs
+// VERSION: 1.0.0
+// START_MODULE_CONTRACT
+//   PURPOSE: CLI-кодген — читает таблицу Schema и печатает типизированный .d.ts-фасад (Data-интерфейсы классов + TypedRow/TypedChain/TypedDb).
+//   SCOPE: парсинг аргументов, чтение Schema, конвертация fastest-validator DSL → TS (ts), эмиссия .d.ts.
+//   DEPENDS: none
+//   LINKS: M-GEN-TYPES, V-M-GEN-TYPES
+//   ROLE: SCRIPT
+//   MAP_MODE: LOCALS
+// END_MODULE_CONTRACT
+//
+// START_MODULE_MAP
+//   ts - fastest-validator DSL → TS-тип ({ t, opt })
+//   ident - безопасный идентификатор либо строковый ключ
+//   sql/rows - чтение классов из таблицы Schema
+//   lines/facade - аккумуляторы генерируемого .d.ts
+// END_MODULE_MAP
+//
+// START_CHANGE_SUMMARY
+//   LAST_CHANGE: [v1.0.0 - Documented existing module: reverse-engineered contract + markup]
+// END_CHANGE_SUMMARY
+import { writeFile } from 'node:fs/promises';
+import postgres from 'postgres';
+
+// START_BLOCK_PARSE_ARGS
+const args = Object.fromEntries(process.argv.slice(2).map((a) => a.replace(/^--/, '').split('=')));
+const dsn = args.dsn ?? process.env.ENTITY_DSN;
+const schema = args.schema ?? 'booking';
+const out = args.out ?? 'entity-types.d.ts';
+if (!dsn) { console.error('usage: tsx scripts/gen-types.mjs --dsn=… --schema=v1.booking [--out=…]'); process.exit(1); }
+
+// END_BLOCK_PARSE_ARGS
+// START_CONTRACT: ts
+//   PURPOSE: Свести attribute-спеку fastest-validator (строка/массив/объект) к TS-типу и признаку optional.
+//   INPUTS: { attr: unknown - правило поля }
+//   OUTPUTS: { { t: string; opt: boolean } }
+//   SIDE_EFFECTS: none (рекурсивно по вложенным props/items)
+//   LINKS: M-GEN-TYPES, V-M-GEN-TYPES
+// END_CONTRACT: ts
+// fastest-validator DSL → TS-тип
+function ts(attr) {
+  if (typeof attr === 'string') {
+    const parts = attr.split('|').map((s) => s.trim());
+    const opt = parts.includes('optional');
+    const base = { number: 'number', boolean: 'boolean', date: 'string', string: 'string', uuid: 'string', email: 'string', url: 'string', any: 'unknown' }[parts[0]] ?? 'unknown';
+    return { t: base, opt };
+  }
+  if (Array.isArray(attr)) { const first = ts(attr[0] ?? 'any'); return { t: first.t, opt: true }; }
+  if (typeof attr === 'object' && attr !== null) {
+    const opt = attr.optional === true;
+    switch (attr.type) {
+      case 'enum': return { t: (attr.values ?? []).map((v) => JSON.stringify(v)).join(' | ') || 'string', opt };
+      case 'record': {
+        const key = attr.key?.type === 'enum' ? (attr.key.values ?? []).map((v) => JSON.stringify(v)).join(' | ') : 'string';
+        return { t: `Partial<Record<${key || 'string'}, number>>`, opt };
+      }
+      case 'array': {
+        const item = ts(attr.items ?? 'any');
+        return { t: `(${item.t})[]`, opt };
+      }
+      case 'number': return { t: 'number', opt };
+      case 'boolean': return { t: 'boolean', opt };
+      case 'date': return { t: 'string', opt };
+      case 'string': case 'uuid': case 'email': case 'url': return { t: 'string', opt };
+      case 'object': {
+        const props = attr.props ?? attr.properties;
+        if (props && typeof props === 'object') {
+          const fields = Object.entries(props)
+            .map(([k, v]) => { const f = ts(v); return `${ident(k)}${f.opt ? '?' : ''}: ${f.t}`; })
+            .join('; ');
+          return { t: `{ ${fields} }`, opt };
+        }
+        return { t: 'Record<string, unknown>', opt };
+      }
+      default: return { t: 'unknown', opt };
+    }
+  }
+  return { t: 'unknown', opt: true };
+}
+
+const ident = (s) => (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(s) ? s : JSON.stringify(s));
+
+// START_BLOCK_READ_SCHEMA
+const sql = postgres(dsn, { max: 1 });
+const rows = await sql.unsafe(
+  `SELECT id, alias, category, attributes, meta FROM "${schema.replaceAll('"', '""')}"."Schema" WHERE partition = 'entity' ORDER BY category, "order"`,
+);
+await sql.end();
+
+// END_BLOCK_READ_SCHEMA
+// START_BLOCK_EMIT_TYPES
+const lines = [
+  '/* Сгенерировано scripts/gen-types.mjs — не редактировать вручную. */',
+  `import type { Row, Filter, Path, Cursor } from 'letopis';`,
+  '',
+  'export interface TypedRow<D> extends Omit<Row, \'data\'> { data: D }',
+  '',
+];
+const facade = [];
+for (const r of rows) {
+  if (r.meta?.abstract === true || r.meta?.abstract === 'true') continue;
+  const name = `${r.id}Data`;
+  lines.push(`/** ${r.category} ${r.id} · ${r.alias} */`, `export interface ${name} {`);
+  for (const [f, attr] of Object.entries(r.attributes)) {
+    if (f === 'id') continue;
+    const { t, opt } = ts(attr);
+    lines.push(`  ${ident(f)}${opt ? '?' : ''}: ${t};`);
+  }
+  lines.push('}', '');
+  for (const key of [r.id, r.alias]) {
+    facade.push(`  ${ident(key)}: (filter?: Filter) => TypedChain<${name}>;`);
+  }
+}
+lines.push(
+  'export interface TypedChain<D> {',
+  '  execute(): Promise<Path[]>;',
+  '  rows(): Promise<TypedRow<D>[]>;',
+  '  first(): Promise<TypedRow<D> | null>;',
+  '  ids(): Promise<string[]>;',
+  '  count(): Promise<number>;',
+  '  versions(): Promise<TypedRow<D>[]>;',
+  '  set(data?: Partial<D> & { id?: string }): PromiseLike<TypedRow<D>[]> & Record<string, (t: string | { id: string }) => unknown>;',
+  '  delete(): Promise<TypedRow<D>[]>;',
+  '  anonymize(fields: (keyof D & string)[]): Promise<TypedRow<D>[]>;',
+  '  limit(n: number): TypedChain<D>;',
+  '  offset(n: number): TypedChain<D>;',
+  '  sort(field: string, dir?: \'asc\' | \'desc\' | boolean): TypedChain<D>;',
+  '  asOf(t: string | Date): TypedChain<D>;',
+  '  after(c: Cursor): TypedChain<D>;',
+  '  alias(name: string): TypedChain<D>;',
+  '  tags(v: string | string[] | object): TypedChain<D>;',
+  '  account(v: string | { id: string }): TypedChain<D>;',
+  '  owner(v: string | { id: string }): TypedChain<D>;',
+  '  [className: string]: unknown;',
+  '}',
+  '',
+  'export interface TypedDb {',
+  ...facade,
+  '}',
+  '',
+);
+// END_BLOCK_EMIT_TYPES
+await writeFile(out, lines.join('\n'), 'utf8');
+console.log(`written ${out}: ${rows.length} classes`);