@coffer-org/server 1.1.0 → 1.2.2

package/dist/collection-io.d.ts

@@ -1,20 +1,24 @@
 import type { EntityManager } from '@mikro-orm/core';
 import type { ModuleDef } from '@coffer-org/sdk/module';
+import type { LayoutEl } from '@coffer-org/sdk/fields';
 type Row = Record<string, unknown>;
-/** Розділити вхід на base-колонки і collection-масиви (по ключах collection-груп). */
-export declare function splitCollections(m: ModuleDef, input: Row): {
+export declare function scalarKeys(fields: LayoutEl[]): string[];
+export declare function splitAt(fields: LayoutEl[], input: Row): {
     base: Row;
     collections: Record<string, Row[]>;
 };
-/** Записати collection-рядки: повна заміна (delete-all + insert) у межах транзакції tx. */
-export declare function writeCollections(tx: EntityManager, m: ModuleDef, parentId: string, collections: Record<string, Row[]>): Promise<void>;
-/** Прочитати всі collection-рядки запису, nest під ключ групи. ORDER BY position. */
-export declare function readCollections(em: EntityManager, m: ModuleDef, parentId: string): Promise<Record<string, Row[]>>;
-/** nested {addr:{city}} → плоско {addr__city}. */
-export declare function flattenEmbedded(m: ModuleDef, input: Row): Row;
-/** плоско {addr__city} → nested {addr:{city}}. */
-export declare function nestEmbedded(m: ModuleDef, row: Row): Row;
-/** Видалити всі collection-рядки запису (каскад при delete батька). */
-export declare function deleteCollections(tx: EntityManager, m: ModuleDef, parentId: string): Promise<void>;
+export declare function writeAt(tx: EntityManager, prefix: string, fields: LayoutEl[], parentId: number, collections: Record<string, Row[]>): Promise<void>;
+export declare function readAt(em: EntityManager, prefix: string, fields: LayoutEl[], parentId: number): Promise<Record<string, Row[]>>;
+export declare function deleteAt(tx: EntityManager, prefix: string, fields: LayoutEl[], parentId: number): Promise<void>;
+export declare const splitCollections: (m: ModuleDef, input: Row) => {
+    base: Row;
+    collections: Record<string, Row[]>;
+};
+export declare const writeCollections: (tx: EntityManager, m: ModuleDef, parentId: number, collections: Record<string, Row[]>) => Promise<void>;
+export declare const readCollections: (em: EntityManager, m: ModuleDef, parentId: number) => Promise<Record<string, Row[]>>;
+export declare const deleteCollections: (tx: EntityManager, m: ModuleDef, parentId: number) => Promise<void>;
+export declare function flattenEmbeddedAt(fields: LayoutEl[], input: Row): Row;
+export declare function nestEmbeddedAt(fields: LayoutEl[], row: Row): Row;
+export declare const flattenEmbedded: (m: ModuleDef, input: Row) => Row;
+export declare const nestEmbedded: (m: ModuleDef, row: Row) => Row;
 export {};
-//# sourceMappingURL=collection-io.d.ts.map

package/dist/collection-io.js

@@ -1,15 +1,26 @@
-/**
- * Read/Write 1↔M collection-груп. Кожна collection-група → child-таблиця
- * vault__module__key з parent_id+position. Дзеркало extend-table.ts, але N рядків.
- */
-import { randomUUID } from 'node:crypto';
 import { serialize } from '@mikro-orm/core';
-import { collectionGroups } from '@coffer-org/sdk/module';
-import { isGroup, isEmbeddedGroup } from '@coffer-org/sdk/fields';
-import { childTableName } from './entity-schema.js';
-/** Розділити вхід на base-колонки і collection-масиви (по ключах collection-груп). */
-export function splitCollections(m, input) {
-    const keys = new Set(collectionGroups(m.fields).map((c) => c.key));
+import { collectionGroups, fieldEntries, storageColumns } from '@coffer-org/sdk/module';
+import { isGroup, isEmbeddedGroup, isJsonStored } from '@coffer-org/sdk/fields';
+function flattenLayout(fields) {
+    const out = [];
+    for (const f of fields) {
+        if (isGroup(f) && !f.key)
+            out.push(...flattenLayout(f.fields));
+        else
+            out.push(f);
+    }
+    return out;
+}
+function collKeySet(fields) {
+    return new Set(collectionGroups(flattenLayout(fields)).map((c) => c.key));
+}
+export function scalarKeys(fields) {
+    return fieldEntries(fields)
+        .filter(([, fm]) => !fm.virtual)
+        .flatMap(([k, fm]) => storageColumns(k, fm).map(([c]) => c));
+}
+export function splitAt(fields, input) {
+    const keys = collKeySet(fields);
     const base = {};
     const collections = {};
     for (const [k, v] of Object.entries(input)) {
@@ -22,39 +33,71 @@ export function splitCollections(m, input) {
     }
     return { base, collections };
 }
-/** Записати collection-рядки: повна заміна (delete-all + insert) у межах транзакції tx. */
-export async function writeCollections(tx, m, parentId, collections) {
-    for (const c of collectionGroups(m.fields)) {
+export async function writeAt(tx, prefix, fields, parentId, collections) {
+    for (const c of collectionGroups(fields)) {
         const rows = collections[c.key];
         if (rows === undefined)
             continue;
-        const table = childTableName(m.vault, m.module, c.key);
+        const table = `${prefix}__${c.key}`;
+        const childFields = c.group.fields;
+        const existing = serialize(await tx.find(table, { parent_id: parentId }));
+        for (const ex of existing)
+            await deleteAt(tx, table, childFields, ex.id);
         await tx.nativeDelete(table, { parent_id: parentId });
+        const sKeys = scalarKeys(childFields);
+        const jsonKeys = new Set(fieldEntries(childFields).filter(([, fm]) => isJsonStored(fm)).map(([k]) => k));
         let position = 0;
         for (const r of rows) {
-            const childKeys = c.group.fields.filter((f) => 'key' in f).map((f) => f.key);
+            const flatR = flattenEmbeddedAt(childFields, r);
             const picked = {};
-            for (const ck of childKeys)
-                if (r[ck] !== undefined)
-                    picked[ck] = r[ck];
-            await tx.upsert(table, { id: randomUUID(), parent_id: parentId, position, ...picked });
+            for (const k of sKeys)
+                if (flatR[k] !== undefined)
+                    picked[k] = jsonKeys.has(k) && flatR[k] !== null && typeof flatR[k] === 'object' ? JSON.stringify(flatR[k]) : flatR[k];
+            const child = tx.create(table, { parent_id: parentId, position, ...picked });
+            await tx.flush();
+            const childId = child.id;
+            const { collections: nested } = splitAt(childFields, r);
+            await writeAt(tx, table, childFields, childId, nested);
             position += 1;
         }
     }
 }
-/** Прочитати всі collection-рядки запису, nest під ключ групи. ORDER BY position. */
-export async function readCollections(em, m, parentId) {
+export async function readAt(em, prefix, fields, parentId) {
     const out = {};
-    for (const c of collectionGroups(m.fields)) {
-        const table = childTableName(m.vault, m.module, c.key);
-        const rows = await em.find(table, { parent_id: parentId }, {
-            orderBy: { position: 'asc' },
-        });
-        out[c.key] = serialize(rows).map(({ id: _id, parent_id: _pid, position: _pos, ...rest }) => rest);
+    for (const c of collectionGroups(fields)) {
+        const table = `${prefix}__${c.key}`;
+        const childFields = c.group.fields;
+        const rows = serialize(await em.find(table, { parent_id: parentId }, { orderBy: { position: 'asc' } }));
+        const acc = [];
+        for (const row of rows) {
+            const { id, parent_id: _pid, position: _pos, ...rest } = row;
+            const nested = await readAt(em, table, childFields, id);
+            acc.push({ ...nestEmbeddedAt(childFields, rest), ...nested });
+        }
+        out[c.key] = acc;
     }
     return out;
 }
-/** Зібрати embedded-групи [key, GroupEl] (рекурсивно крізь layout). */
+export async function deleteAt(tx, prefix, fields, parentId) {
+    for (const c of collectionGroups(fields)) {
+        const table = `${prefix}__${c.key}`;
+        const childFields = c.group.fields;
+        const children = serialize(await tx.find(table, { parent_id: parentId }));
+        for (const ch of children)
+            await deleteAt(tx, table, childFields, ch.id);
+        await tx.nativeDelete(table, { parent_id: parentId });
+    }
+}
+const modPrefix = (m) => `${m.vault}__${m.module}`;
+export const splitCollections = (m, input) => splitAt(m.fields, input);
+export const writeCollections = (tx, m, parentId, collections) => writeAt(tx, modPrefix(m), m.fields, parentId, collections);
+export const readCollections = (em, m, parentId) => readAt(em, modPrefix(m), m.fields, parentId);
+export const deleteCollections = (tx, m, parentId) => deleteAt(tx, modPrefix(m), m.fields, parentId);
+function columnsTargets(fields) {
+    return fieldEntries(fields)
+        .filter(([, fm]) => fm.columns)
+        .map(([k, fm]) => [k, Object.keys(fm.columns)]);
+}
 function embeddedGroups(fields) {
     const out = [];
     for (const it of fields) {
@@ -65,10 +108,9 @@ function embeddedGroups(fields) {
     }
     return out;
 }
-/** nested {addr:{city}} → плоско {addr__city}. */
-export function flattenEmbedded(m, input) {
+export function flattenEmbeddedAt(fields, input) {
     const out = { ...input };
-    for (const [key, g] of embeddedGroups(m.fields)) {
+    for (const [key, g] of embeddedGroups(fields)) {
         const nested = out[key];
         delete out[key];
         if (nested && typeof nested === 'object') {
@@ -78,12 +120,32 @@ export function flattenEmbedded(m, input) {
             }
         }
     }
+    for (const [key, subs] of columnsTargets(fields)) {
+        const obj = out[key];
+        delete out[key];
+        if (obj && typeof obj === 'object')
+            for (const s of subs)
+                out[`${key}__${s}`] = obj[s];
+    }
     return out;
 }
-/** плоско {addr__city} → nested {addr:{city}}. */
-export function nestEmbedded(m, row) {
+export function nestEmbeddedAt(fields, row) {
     const out = { ...row };
-    for (const [key, g] of embeddedGroups(m.fields)) {
+    for (const [key, subs] of columnsTargets(fields)) {
+        const nested = {};
+        let any = false;
+        for (const s of subs) {
+            const col = `${key}__${s}`;
+            if (col in out) {
+                nested[s] = out[col];
+                delete out[col];
+                any = true;
+            }
+        }
+        if (any)
+            out[key] = nested;
+    }
+    for (const [key, g] of embeddedGroups(fields)) {
         const nested = {};
         let any = false;
         for (const f of g.fields) {
@@ -101,11 +163,5 @@ export function nestEmbedded(m, row) {
     }
     return out;
 }
-/** Видалити всі collection-рядки запису (каскад при delete батька). */
-export async function deleteCollections(tx, m, parentId) {
-    for (const c of collectionGroups(m.fields)) {
-        const table = childTableName(m.vault, m.module, c.key);
-        await tx.nativeDelete(table, { parent_id: parentId });
-    }
-}
-//# sourceMappingURL=collection-io.js.map
+export const flattenEmbedded = (m, input) => flattenEmbeddedAt(m.fields, input);
+export const nestEmbedded = (m, row) => nestEmbeddedAt(m.fields, row);

package/dist/db.d.ts

@@ -2,5 +2,5 @@ import { MikroORM } from '@mikro-orm/core';
 import type { EntitySchema, EntityManager } from '@mikro-orm/core';
 export declare function getOrm(): MikroORM;
 export declare function getEm(): EntityManager;
+export declare function closeDb(): Promise<void>;
 export declare function initDb(entities: EntitySchema[]): Promise<MikroORM>;
-//# sourceMappingURL=db.d.ts.map

package/dist/db.js

@@ -1,45 +1,42 @@
-/**
- * Підключення до БД через MikroORM (SQLite).
- * ORM-шар навмисно тонкий: щоб перейти на Postgres —
- *   1. `npm install @mikro-orm/postgresql`,
- *   2. змінити SqliteDriver на PostgreSqlDriver,
- *   3. dbName на рядок підключення.
- *
- * WAL-режим: у MikroORM v7 @mikro-orm/sqlite працює на better-sqlite3
- * (синхронний драйвер, без knex-пулу), тому WAL ставимо через PRAGMA одразу
- * після MikroORM.init(). WAL персистентний (зберігається в заголовку файлу БД),
- * тож одного виклику достатньо. foreign_keys=ON MikroORM вмикає сам.
- */
 import { mkdirSync } from 'node:fs';
 import { dirname } from 'node:path';
 import { MikroORM, EntityCaseNamingStrategy } from '@mikro-orm/core';
 import { SqliteDriver } from '@mikro-orm/sqlite';
-const DB_PATH = process.env['DB_PATH'] ?? 'data/app.db';
-mkdirSync(dirname(DB_PATH), { recursive: true });
-// Синглтони — заповнюються в initDb().
 let _orm;
 export function getOrm() {
     if (!_orm)
-        throw new Error('initDb() ще не викликано');
+        throw new Error('initDb() has not been called yet');
     return _orm;
 }
 export function getEm() {
     if (!_orm)
-        throw new Error('initDb() ще не викликано');
+        throw new Error('initDb() has not been called yet');
     return _orm.em;
 }
+export async function closeDb() {
+    if (!_orm)
+        return;
+    await _orm.close();
+    _orm = undefined;
+}
 export async function initDb(entities) {
-    _orm = await MikroORM.init({
-        driver: SqliteDriver,
-        dbName: DB_PATH,
+    const driverName = process.env['DB_DRIVER'] ?? 'sqlite';
+    const common = {
         entities,
-        // Властивості → колонки дослівно (camelCase поля плагінів зберігаються як є):
-        // camelCase-поля плагінів лишаються camelCase у БД, snake_case системні — як є.
         namingStrategy: EntityCaseNamingStrategy,
         discovery: { warnWhenNoEntities: false },
-    });
-    // WAL через PRAGMA (better-sqlite3, без knex-пулу — див. коментар угорі файлу).
+    };
+    if (driverName === 'postgresql') {
+        const { PostgreSqlDriver } = await import('@mikro-orm/postgresql');
+        const clientUrl = process.env['DATABASE_URL'];
+        if (!clientUrl)
+            throw new Error('DB_DRIVER=postgresql requires DATABASE_URL');
+        _orm = await MikroORM.init({ driver: PostgreSqlDriver, clientUrl, ...common });
+        return _orm;
+    }
+    const dbPath = process.env['DB_PATH'] ?? 'data/app.db';
+    mkdirSync(dirname(dbPath), { recursive: true });
+    _orm = await MikroORM.init({ driver: SqliteDriver, dbName: dbPath, ...common });
     await _orm.em.getConnection().execute('PRAGMA journal_mode = WAL');
     return _orm;
 }
-//# sourceMappingURL=db.js.map

package/dist/dialect.d.ts

@@ -0,0 +1,4 @@
+import type { EntityManager } from '@mikro-orm/core';
+export type Dialect = 'sqlite' | 'postgresql' | 'mysql';
+export declare function dialectOf(em: EntityManager): Dialect;
+export declare function getDialect(): Dialect;

package/dist/dialect.js

@@ -0,0 +1,14 @@
+import { getEm } from "./db.js";
+export function dialectOf(em) {
+    const name = em.getPlatform().constructor.name;
+    if (name.startsWith('Sqlite'))
+        return 'sqlite';
+    if (name.startsWith('PostgreSql'))
+        return 'postgresql';
+    if (name.startsWith('MySql') || name.startsWith('MariaDb'))
+        return 'mysql';
+    throw new Error(`[dialect] unknown platform: ${name}`);
+}
+export function getDialect() {
+    return dialectOf(getEm());
+}

package/dist/embed.d.ts

@@ -0,0 +1,14 @@
+export interface EmbedRec {
+    url: string;
+    title?: string;
+    description?: string;
+    thumbnail?: string;
+    provider?: string;
+    type?: 'video' | 'rich' | 'photo' | 'link';
+    html?: string;
+    width?: number;
+    height?: number;
+}
+export declare function mapOembed(url: string, o: Record<string, unknown>): EmbedRec;
+export declare function mapOg(url: string, r: Record<string, unknown>): EmbedRec;
+export declare function resolveEmbed(url: string): Promise<EmbedRec | null>;

package/dist/embed.js

@@ -0,0 +1,46 @@
+import { extract } from '@extractus/oembed-extractor';
+import ogs from 'open-graph-scraper';
+const num = (v) => (typeof v === 'number' ? v : undefined);
+const str = (v) => (typeof v === 'string' && v ? v : undefined);
+export function mapOembed(url, o) {
+    const t = str(o.type);
+    const type = t === 'video' || t === 'rich' || t === 'photo' ? t : 'rich';
+    return {
+        url,
+        type,
+        title: str(o.title),
+        thumbnail: str(o.thumbnail_url),
+        provider: str(o.provider_name),
+        html: str(o.html),
+        width: num(o.width),
+        height: num(o.height),
+    };
+}
+export function mapOg(url, r) {
+    const imgs = r.ogImage;
+    return {
+        url,
+        type: 'link',
+        title: str(r.ogTitle),
+        description: str(r.ogDescription),
+        thumbnail: Array.isArray(imgs) ? str(imgs[0]?.url) : undefined,
+        provider: str(r.ogSiteName),
+    };
+}
+export async function resolveEmbed(url) {
+    try {
+        const o = (await extract(url));
+        if (o)
+            return mapOembed(url, o);
+    }
+    catch {
+    }
+    try {
+        const { result, error } = await ogs({ url });
+        if (!error && result)
+            return mapOg(url, result);
+    }
+    catch {
+    }
+    return null;
+}

package/dist/embeddings.d.ts

@@ -0,0 +1,38 @@
+export type EmbeddingHit = {
+    type: string;
+    recordId: number;
+    snippet: string;
+    distance: number;
+};
+export type EmbeddingRow = {
+    type: string;
+    recordId: number;
+    snippet: string;
+    full: Float32Array;
+};
+export type EventRow = {
+    id: number;
+    op: string;
+    type: string;
+    record_id: number | null;
+    after: string | null;
+};
+export declare function invalidateEmbeddingCache(): void;
+export declare function encodeVector(v: number[]): Buffer;
+export declare function decodeVector(b: Buffer): Float32Array;
+export declare function migrateEmbeddingVectorsToBlob(): Promise<number>;
+export declare function cosine(a: ArrayLike<number>, b: ArrayLike<number>): number;
+export declare function twoPassSearch(rows: EmbeddingRow[], queryVec: ArrayLike<number>, k: number, opts?: {
+    coarseDims?: number;
+    poolMinFactor?: number;
+}): EmbeddingHit[];
+export declare function upsertEmbedding(args: {
+    type: string;
+    recordId: number;
+    snippet: string;
+    vector: number[];
+    model: string;
+}): Promise<void>;
+export declare function deleteEmbedding(type: string, recordId: number): Promise<void>;
+export declare function searchEmbeddings(queryVec: number[], k: number): Promise<EmbeddingHit[]>;
+export declare function listEventsSince(lastId: number, limit: number): Promise<EventRow[]>;

package/dist/embeddings.js

@@ -0,0 +1,109 @@
+import { getEm } from "./db.js";
+import { dialectOf } from "./dialect.js";
+const COARSE_DIMS = 64;
+const POOL_MIN_FACTOR = 4;
+let cache = null;
+export function invalidateEmbeddingCache() {
+    cache = null;
+}
+async function loadCache() {
+    if (cache)
+        return cache;
+    const em = getEm().fork();
+    const rows = (await em.find('_Embedding', {}));
+    cache = rows.map((r) => ({
+        type: r.type, recordId: r.record_id, snippet: r.snippet, full: decodeVector(r.vector),
+    }));
+    return cache;
+}
+export function encodeVector(v) {
+    return Buffer.from(new Float32Array(v).buffer);
+}
+export function decodeVector(b) {
+    return new Float32Array(b.buffer, b.byteOffset, Math.floor(b.byteLength / 4));
+}
+function decodeBase64Vector(s) {
+    const buf = Buffer.from(s, 'base64');
+    return new Float32Array(buf.buffer, buf.byteOffset, Math.floor(buf.byteLength / 4));
+}
+export async function migrateEmbeddingVectorsToBlob() {
+    const em = getEm().fork();
+    if (dialectOf(em) !== 'sqlite')
+        return 0;
+    const [{ n }] = (await em.getConnection().execute("SELECT count(*) AS n FROM _embeddings WHERE typeof(vector) = 'text'"));
+    if (n === 0)
+        return 0;
+    const rows = (await em.find('_Embedding', {}));
+    let migrated = 0;
+    for (const r of rows) {
+        if (typeof r.vector !== 'string')
+            continue;
+        const f = decodeBase64Vector(r.vector);
+        await em.nativeUpdate('_Embedding', { type: r.type, record_id: r.record_id }, { vector: Buffer.from(f.buffer, f.byteOffset, f.byteLength) });
+        migrated++;
+    }
+    if (migrated > 0) {
+        invalidateEmbeddingCache();
+    }
+    return migrated;
+}
+export function cosine(a, b) {
+    let dot = 0, na = 0, nb = 0;
+    const n = Math.min(a.length, b.length);
+    for (let i = 0; i < n; i++) {
+        dot += a[i] * b[i];
+        na += a[i] * a[i];
+        nb += b[i] * b[i];
+    }
+    const denom = Math.sqrt(na) * Math.sqrt(nb);
+    return denom ? dot / denom : 0;
+}
+export function twoPassSearch(rows, queryVec, k, opts = {}) {
+    const N = rows.length;
+    if (N === 0)
+        return [];
+    const coarseDims = opts.coarseDims ?? COARSE_DIMS;
+    const poolMinFactor = opts.poolMinFactor ?? POOL_MIN_FACTOR;
+    const qFull = queryVec instanceof Float32Array ? queryVec : Float32Array.from(queryVec);
+    const m = Math.min(coarseDims, qFull.length);
+    const qSmall = qFull.subarray(0, m);
+    const poolSize = Math.min(N, Math.max(k * poolMinFactor, Math.ceil(N * 0.1)));
+    const pool = rows
+        .map((r, i) => ({ i, d: 1 - cosine(r.full.subarray(0, m), qSmall) }))
+        .sort((a, b) => a.d - b.d)
+        .slice(0, poolSize);
+    return pool
+        .map(({ i }) => {
+        const r = rows[i];
+        return { type: r.type, recordId: r.recordId, snippet: r.snippet, distance: 1 - cosine(r.full, qFull) };
+    })
+        .sort((a, b) => a.distance - b.distance)
+        .slice(0, k);
+}
+export async function upsertEmbedding(args) {
+    const em = getEm().fork();
+    await em.upsert('_Embedding', {
+        type: args.type,
+        record_id: args.recordId,
+        snippet: args.snippet,
+        vector: encodeVector(args.vector),
+        model: args.model,
+        dim: args.vector.length,
+        updated_at: new Date().toISOString(),
+    });
+    await em.flush();
+    invalidateEmbeddingCache();
+}
+export async function deleteEmbedding(type, recordId) {
+    const em = getEm().fork();
+    await em.nativeDelete('_Embedding', { type, record_id: recordId });
+    invalidateEmbeddingCache();
+}
+export async function searchEmbeddings(queryVec, k) {
+    return twoPassSearch(await loadCache(), queryVec, k);
+}
+export async function listEventsSince(lastId, limit) {
+    const em = getEm().fork();
+    const rows = (await em.find('_Event', { id: { $gt: lastId } }, { orderBy: { id: 'ASC' }, limit }));
+    return rows;
+}

package/dist/entity-schema.d.ts

@@ -1,32 +1,21 @@
-/**
- * MikroORM EntitySchema — похідна від ModuleDef/ExtendDef (джерело істини: f.*).
- * DB-agnostic: імпортує лише @mikro-orm/core + типи ядра.
- * Колонки: text→text, integer→integer, real→float, boolean→boolean.
- *
- * Фізичну схему створює runtime-синк (schema-sync.ts) з цих описів.
- * Тут — лише in-memory опис для типобезпечних запитів.
- */
 import { EntitySchema } from '@mikro-orm/core';
 import type { ModuleDef } from '@coffer-org/sdk/module';
 import type { ExtendDef } from '@coffer-org/sdk/extend';
 import type { SettingsDef } from '@coffer-org/sdk/settings';
 import type { PluginManifest } from '@coffer-org/sdk/plugin';
-/** Ім'я сутності (= ім'я таблиці) для модуля: vault__module. */
 export declare function moduleTableName(vault: string, module: string): string;
-/** EntitySchema для одного модуля плагіна. */
 export declare function buildEntitySchema(m: ModuleDef): EntitySchema;
-/** EntitySchema для extend-таблиці (PK = base_id). */
 export declare function buildExtendEntitySchema(e: ExtendDef): EntitySchema;
-/** EntitySchema для singleton-таблиці налаштувань плагіна. PK = plugin_id. */
 export declare function buildSettingsEntitySchema(pluginId: string, settings: SettingsDef): EntitySchema;
-/** Ім'я child-таблиці collection-групи. */
 export declare function childTableName(vault: string, module: string, key: string): string;
-/** Усі child-схеми модуля (рекурсивно: collection усередині collection). */
 export declare function buildCollectionEntities(m: ModuleDef): EntitySchema[];
+export declare function buildExtendCollectionEntities(e: ExtendDef): EntitySchema[];
 export declare const EventSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
 export declare const PluginRowSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
-/** Схеми сутностей плагінів (модулі власних vault'ів + vaultModules + extends + settings). */
+export declare const MigrationRowSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
+export declare const SeedRowSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
+export declare const EmbeddingSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
+export declare const PluginStateSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
 export declare function buildPluginEntities(plugins: PluginManifest[]): EntitySchema[];
-/** Системні схеми — реєструються в initDb() ДО читання _plugins. */
+export declare const MsgLogSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
 export declare const systemEntities: EntitySchema[];
-//# sourceMappingURL=entity-schema.d.ts.map