@coffer-org/server 1.1.0 → 1.2.0

package/dist/local-api.js

@@ -1,46 +1,18 @@
-/**
- * In-process API — той самий запис, що й REST-роути, але без HTTP.
- * Потрібен для імпорту/сидів у середовищах, де піднятий сервер не годиться
- * (напр. пісочниця, що скидає overlay вбитого процесу): процес-писар сам
- * мутує БД і чисто завершується → дані персистяться.
- *
- * Повторює логіку app.post/app.patch з index.ts: split _extend_<id> → base,
- * createRecord/updateRecord (mutate), upsert extends.
- */
-import { getModule } from './registry-context.js';
-import { createRecord, updateRecord, getRecord } from './mutate.js';
-import { moduleTableName } from './entity-schema.js';
-import { splitBody, saveExtends } from './extend-io.js';
-/** Ім'я таблиці для (vault, type), якщо модуль відомий. Реєстр in-memory — без кешу. */
-function enameFor(vault, type) {
-    const m = getModule(vault, type);
-    return m ? moduleTableName(m.vault, m.module) : undefined;
-}
-export class UnknownTypeError extends Error {
-}
+import { recordCreate, recordUpdate, recordGet, UnknownTypeError } from "./records-api.js";
+export { UnknownTypeError };
 export async function localExists(vault, type, id) {
-    const m = getModule(vault, type);
-    const ename = enameFor(vault, type);
-    return m && ename ? Boolean(await getRecord(m, ename, id)) : false;
+    try {
+        return Boolean(await recordGet(vault, type, id));
+    }
+    catch (e) {
+        if (e instanceof UnknownTypeError)
+            return false;
+        throw e;
+    }
 }
-export async function localPost(vault, type, body) {
-    const m = getModule(vault, type);
-    const ename = enameFor(vault, type);
-    if (!m || !ename)
-        throw new UnknownTypeError(`unknown_type ${vault}/${type}`);
-    const { base, extData } = splitBody(body);
-    const row = await createRecord(m, ename, base, { actor: 'import' });
-    await saveExtends(vault, type, String(row.id), extData);
-    return row;
+export function localPost(vault, type, body) {
+    return recordCreate(vault, type, body, 'import');
 }
-export async function localPatch(vault, type, id, body) {
-    const m = getModule(vault, type);
-    const ename = enameFor(vault, type);
-    if (!m || !ename)
-        throw new UnknownTypeError(`unknown_type ${vault}/${type}`);
-    const { base, extData } = splitBody(body);
-    const row = await updateRecord(m, ename, id, base, { actor: 'import' });
-    await saveExtends(vault, type, id, extData);
-    return row;
+export function localPatch(vault, type, id, body) {
+    return recordUpdate(vault, type, id, body, 'import');
 }
-//# sourceMappingURL=local-api.js.map

package/dist/migrations.d.ts

@@ -0,0 +1,24 @@
+import type { EntityManager, EntitySchema } from '@mikro-orm/core';
+import type { Migration, PluginHooks, TableOps } from './plugin-hooks.ts';
+export declare function introspectTable(em: EntityManager, table: string): Promise<{
+    exists: boolean;
+    columns: Set<string>;
+    indexes: {
+        columnNames: string[];
+        unique: boolean;
+        primary: boolean;
+    }[];
+}>;
+export declare function makeTable(em: EntityManager, table: string): TableOps;
+export declare function validateMigrations(pluginId: string, list: Migration[]): void;
+interface RunArgs {
+    em: EntityManager;
+    plugins: {
+        id: string;
+        tables?: string[];
+    }[];
+    hooks: Record<string, PluginHooks>;
+}
+export declare function runMigrations({ em, plugins, hooks }: RunArgs): Promise<void>;
+export declare function assertSafeRequired(em: EntityManager, entities: EntitySchema[]): Promise<void>;
+export {};

package/dist/migrations.js

@@ -0,0 +1,198 @@
+import { DatabaseSchema } from '@mikro-orm/sql';
+import { dialectOf } from "./dialect.js";
+function sqlType(col) {
+    if (col === 'integer' || col === 'boolean')
+        return 'integer';
+    if (col === 'real')
+        return 'real';
+    return 'text';
+}
+function pgType(col) {
+    if (col === 'integer')
+        return 'integer';
+    if (col === 'real')
+        return 'double precision';
+    if (col === 'boolean')
+        return 'boolean';
+    if (col === 'date')
+        return 'date';
+    if (col === 'time')
+        return 'time';
+    if (col === 'datetime')
+        return 'timestamptz';
+    return 'text';
+}
+const q = (id) => `"${id.replace(/"/g, '""')}"`;
+export async function introspectTable(em, table) {
+    const conn = em.getConnection();
+    const platform = em.getPlatform();
+    const schema = await DatabaseSchema.create(conn, platform, em.config, undefined, undefined, [table]);
+    const t = schema.getTable(table);
+    return {
+        exists: !!t,
+        columns: new Set(t ? t.getColumns().map((c) => c.name) : []),
+        indexes: t ? t.getIndexes().map((i) => ({ columnNames: i.columnNames ?? [], unique: !!i.unique, primary: !!i.primary })) : [],
+    };
+}
+export function makeTable(em, table) {
+    const conn = em.getConnection();
+    const T = q(table);
+    return {
+        async renameColumn(from, to) {
+            const info = await introspectTable(em, table);
+            if (!info.exists || !info.columns.has(from))
+                return;
+            await conn.execute(`ALTER TABLE ${T} RENAME COLUMN ${q(from)} TO ${q(to)}`);
+        },
+        async fill(column, value, opts) {
+            const info = await introspectTable(em, table);
+            if (!info.exists || !info.columns.has(column))
+                return;
+            const where = opts?.where ?? {};
+            const keys = Object.keys(where);
+            const clauses = keys.map((k) => (where[k] === null ? `${q(k)} IS NULL` : `${q(k)} = ?`));
+            const params = [value, ...keys.filter((k) => where[k] !== null).map((k) => where[k])];
+            const sql = `UPDATE ${T} SET ${q(column)} = ?` + (clauses.length ? ` WHERE ${clauses.join(' AND ')}` : '');
+            await conn.execute(sql, params);
+        },
+        async changeType(column, newType, opts) {
+            const info = await introspectTable(em, table);
+            if (!info.exists || !info.columns.has(column))
+                return;
+            const tmp = `__ct_${column}`;
+            const def = opts?.default;
+            if (dialectOf(em) === 'sqlite') {
+                await conn.execute(`BEGIN`);
+                try {
+                    await conn.execute(`ALTER TABLE ${T} ADD COLUMN ${q(tmp)} ${sqlType(newType)}`);
+                    if (opts?.transform) {
+                        const rows = (await conn.execute(`SELECT rowid AS __rid, ${q(column)} AS __old FROM ${T}`));
+                        for (const r of rows) {
+                            let next = opts.transform(r.__old);
+                            if (next === null || next === undefined || (typeof next === 'number' && Number.isNaN(next)))
+                                next = def ?? null;
+                            await conn.execute(`UPDATE ${T} SET ${q(tmp)} = ? WHERE rowid = ?`, [next, r.__rid]);
+                        }
+                    }
+                    else {
+                        await conn.execute(`UPDATE ${T} SET ${q(tmp)} = ${q(column)}`);
+                        if (def !== undefined)
+                            await conn.execute(`UPDATE ${T} SET ${q(tmp)} = ? WHERE ${q(tmp)} IS NULL`, [def]);
+                    }
+                    const savedIndexSql = [];
+                    const idxList = (await conn.execute(`PRAGMA index_list(${q(table)})`));
+                    for (const idx of idxList) {
+                        const info = (await conn.execute(`PRAGMA index_info(${q(idx.name)})`));
+                        if (!info.some((c) => c.name === column))
+                            continue;
+                        const meta = (await conn.execute(`SELECT sql FROM sqlite_master WHERE type='index' AND name=?`, [idx.name]));
+                        const sql = meta[0]?.sql;
+                        if (sql == null)
+                            continue;
+                        savedIndexSql.push(sql);
+                        await conn.execute(`DROP INDEX ${q(idx.name)}`);
+                    }
+                    await conn.execute(`ALTER TABLE ${T} DROP COLUMN ${q(column)}`);
+                    await conn.execute(`ALTER TABLE ${T} RENAME COLUMN ${q(tmp)} TO ${q(column)}`);
+                    for (const sql of savedIndexSql)
+                        await conn.execute(sql);
+                    await conn.execute(`COMMIT`);
+                }
+                catch (e) {
+                    await conn.execute(`ROLLBACK`);
+                    throw e;
+                }
+                return;
+            }
+            await conn.execute(`BEGIN`);
+            try {
+                await conn.execute(`ALTER TABLE ${T} ADD COLUMN ${q(tmp)} ${pgType(newType)}`);
+                if (opts?.transform) {
+                    const rows = (await conn.execute(`SELECT id AS __rid, ${q(column)} AS __old FROM ${T}`));
+                    for (const r of rows) {
+                        let next = opts.transform(r.__old);
+                        if (next === null || next === undefined || (typeof next === 'number' && Number.isNaN(next)))
+                            next = def ?? null;
+                        await conn.execute(`UPDATE ${T} SET ${q(tmp)} = ? WHERE id = ?`, [next, r.__rid]);
+                    }
+                }
+                else {
+                    await conn.execute(`UPDATE ${T} SET ${q(tmp)} = ${q(column)}::${pgType(newType)}`);
+                    if (def !== undefined)
+                        await conn.execute(`UPDATE ${T} SET ${q(tmp)} = ? WHERE ${q(tmp)} IS NULL`, [def]);
+                }
+                await conn.execute(`ALTER TABLE ${T} DROP COLUMN ${q(column)}`);
+                await conn.execute(`ALTER TABLE ${T} RENAME COLUMN ${q(tmp)} TO ${q(column)}`);
+                await conn.execute(`COMMIT`);
+            }
+            catch (e) {
+                await conn.execute(`ROLLBACK`);
+                throw e;
+            }
+        },
+    };
+}
+export function validateMigrations(pluginId, list) {
+    const versions = list.map((m) => m.version).sort((a, b) => a - b);
+    versions.forEach((v, i) => {
+        if (v !== i + 1) {
+            throw new Error(`[migrations] ${pluginId}: versions must be contiguous 1..N without duplicates — got [${list.map((m) => m.version).join(', ')}]`);
+        }
+    });
+}
+async function anyTableExists(em, tables) {
+    for (const t of tables)
+        if ((await introspectTable(em, t)).exists)
+            return true;
+    return false;
+}
+export async function runMigrations({ em, plugins, hooks }) {
+    const conn = em.getConnection();
+    for (const p of plugins) {
+        const list = hooks[p.id]?.migrations ?? [];
+        if (!list.length)
+            continue;
+        validateMigrations(p.id, list);
+        const journal = (await conn.execute(`SELECT version FROM _migrations WHERE plugin_id = ?`, [p.id]));
+        const stored = journal[0]?.version ?? 0;
+        const maxV = Math.max(...list.map((m) => m.version));
+        if (maxV <= stored)
+            continue;
+        if (p.tables?.length && !(await anyTableExists(em, p.tables))) {
+            await conn.execute(`INSERT INTO _migrations (plugin_id, version) VALUES (?, ?)
+         ON CONFLICT(plugin_id) DO UPDATE SET version = excluded.version`, [p.id, maxV]);
+            console.log(`[migrations] ${p.id}: fresh DB → stamp v${maxV} (no run)`);
+            continue;
+        }
+        const pending = [...list].filter((m) => m.version > stored).sort((a, b) => a.version - b.version);
+        const ctx = { table: (name) => makeTable(em, name) };
+        for (const m of pending) {
+            await m.up(ctx);
+            await conn.execute(`INSERT INTO _migrations (plugin_id, version) VALUES (?, ?)
+         ON CONFLICT(plugin_id) DO UPDATE SET version = excluded.version`, [p.id, m.version]);
+        }
+        if (pending.length)
+            console.log(`[migrations] ${p.id}: applied ${pending.length} (→ v${pending[pending.length - 1].version})`);
+    }
+}
+export async function assertSafeRequired(em, entities) {
+    const conn = em.getConnection();
+    for (const e of entities) {
+        const meta = e.meta;
+        const tableName = meta.tableName;
+        const props = Object.entries(meta.properties).filter(([, p]) => !p.primary && p.nullable === false && p.default === undefined);
+        if (!props.length)
+            continue;
+        const info = await introspectTable(em, tableName);
+        if (!info.exists)
+            continue;
+        const cnt = (await conn.execute(`SELECT COUNT(*) AS n FROM ${q(tableName)}`));
+        if (!(cnt[0]?.n ?? 0))
+            continue;
+        for (const [col] of props) {
+            if (info.columns.has(col))
+                continue;
+            throw new Error(`[migrations] ${tableName}.${col}: a required field without a default is being added to a non-empty table — add a default in f.* (the field) or a backfill migration`);
+        }
+    }
+}

package/dist/msg-log.d.ts

@@ -0,0 +1,12 @@
+export interface MsgLogRow {
+    connector: string;
+    chatId: string;
+    userId: string;
+    role: 'user' | 'assistant';
+    text: string;
+    sessionId: string | null;
+    tokensIn: number | null;
+    tokensOut: number | null;
+    ms: number | null;
+}
+export declare function logMessage(row: MsgLogRow): Promise<void>;

package/dist/msg-log.js

@@ -0,0 +1,5 @@
+import { getEm } from "./db.js";
+export async function logMessage(row) {
+    await getEm().fork().getConnection().execute(`INSERT INTO _orch_msg_log (ts, connector, chat_id, user_id, role, text, session_id, tokens_in, tokens_out, ms)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [new Date().toISOString(), row.connector, row.chatId, row.userId, row.role, row.text, row.sessionId, row.tokensIn, row.tokensOut, row.ms]);
+}

package/dist/mutate.d.ts

@@ -1,4 +1,5 @@
 import type { ModuleDef } from '@coffer-org/sdk/module';
+import { z } from 'zod';
 export interface MutateCtx {
     actor: string;
 }
@@ -6,6 +7,7 @@ export interface ValidationIssue {
     field: string;
     code: string;
     params?: Record<string, unknown>;
+    path: (string | number)[];
 }
 export declare class ValidationError extends Error {
     issues: ValidationIssue[];
@@ -14,9 +16,9 @@ export declare class ValidationError extends Error {
 export declare class NotFoundError extends Error {
     constructor();
 }
+export declare function toIssue(i: z.ZodIssue): ValidationIssue;
 export declare function listRecords(entityName: string): Promise<Record<string, unknown>[]>;
-export declare function getRecord(m: ModuleDef, entityName: string, id: string): Promise<Record<string, unknown> | undefined>;
+export declare function getRecord(m: ModuleDef, entityName: string, id: number): Promise<Record<string, unknown> | undefined>;
 export declare function createRecord(m: ModuleDef, entityName: string, input: unknown, ctx: MutateCtx): Promise<Record<string, unknown>>;
-export declare function updateRecord(m: ModuleDef, entityName: string, id: string, input: unknown, ctx: MutateCtx): Promise<Record<string, unknown>>;
-export declare function deleteRecord(m: ModuleDef, entityName: string, id: string, ctx: MutateCtx): Promise<void>;
-//# sourceMappingURL=mutate.d.ts.map
+export declare function updateRecord(m: ModuleDef, entityName: string, id: number, input: unknown, ctx: MutateCtx): Promise<Record<string, unknown>>;
+export declare function deleteRecord(m: ModuleDef, entityName: string, id: number, ctx: MutateCtx): Promise<void>;

package/dist/mutate.js

@@ -1,16 +1,22 @@
-/**
- * ЄДИНИЙ ШЛЯХ ЗАПИСУ. Усі мутації проходять тут.
- * validate (Zod) → транзакція → append-only audit (_events).
- */
-import { randomUUID } from 'node:crypto';
 import { serialize } from '@mikro-orm/core';
-import { buildZodObject, buildZodObjectPartial } from '@coffer-org/sdk/module';
-import { getEm } from './db.js';
-import { encodeTemporal, decodeTemporal } from './temporal.js';
-import { splitCollections, writeCollections, deleteCollections, flattenEmbedded, nestEmbedded, readCollections, } from './collection-io.js';
+import { buildZodObject, buildZodObjectPartial, fieldEntries } from '@coffer-org/sdk/module';
+import { isJsonStored, decodeVmsg } from '@coffer-org/sdk/fields';
+import { resolveFlag } from '@coffer-org/sdk/condition';
+import { getEm } from "./db.js";
+import { encodeTemporal, decodeTemporal } from "./temporal.js";
+import { splitCollections, writeCollections, deleteCollections, flattenEmbedded, nestEmbedded, readCollections, } from "./collection-io.js";
 function nowIso() {
     return new Date().toISOString();
 }
+function encodeJson(m, data) {
+    const out = { ...data };
+    for (const [k, f] of fieldEntries(m.fields)) {
+        if (isJsonStored(f) && out[k] !== null && out[k] !== undefined && typeof out[k] === 'object') {
+            out[k] = JSON.stringify(out[k]);
+        }
+    }
+    return out;
+}
 export class ValidationError extends Error {
     issues;
     constructor(issues) {
@@ -21,25 +27,18 @@ export class ValidationError extends Error {
 }
 export class NotFoundError extends Error {
     constructor() {
-        super('Не знайдено');
+        super('Not found');
         this.name = 'NotFoundError';
     }
 }
-function toIssue(i) {
+export function toIssue(i) {
+    const path = i.path.map((p) => (typeof p === 'number' ? p : String(p)));
     const field = String(i.path[0] ?? '');
-    try {
-        const m = JSON.parse(i.message);
-        if (typeof m.code === 'string')
-            return { field, code: m.code, params: m.params };
-    }
-    catch {
-        /* не-vmsg повідомлення від zod */
-    }
-    return { field, code: 'invalid' };
+    const { code, params } = decodeVmsg(i.message);
+    return params ? { field, code, params, path } : { field, code, path };
 }
 function writeEvent(em, actor, op, type, recordId, before, after) {
     em.create('_Event', {
-        id: randomUUID(),
         ts: nowIso(),
         actor,
         op,
@@ -49,10 +48,9 @@ function writeEvent(em, actor, op, type, recordId, before, after) {
         after: after == null ? null : JSON.stringify(after),
     });
 }
-// ─── READ ─────────────────────────────────────────────────────────────────────
 export async function listRecords(entityName) {
     const fork = getEm().fork();
-    const rows = await fork.findAll(entityName);
+    const rows = await fork.findAll(entityName, { orderBy: { id: 'asc' } });
     return serialize(rows);
 }
 export async function getRecord(m, entityName, id) {
@@ -65,27 +63,26 @@ export async function getRecord(m, entityName, id) {
     const collections = await readCollections(fork, m, id);
     return { ...nested, ...collections };
 }
-// ─── CREATE ───────────────────────────────────────────────────────────────────
 export async function createRecord(m, entityName, input, ctx) {
-    const rawInput = (input ?? {});
     const parsed = buildZodObject(m).safeParse(input);
     if (!parsed.success)
         throw new ValidationError(parsed.error.issues.map(toIssue));
-    const id = typeof rawInput.id === 'string' && rawInput.id ? rawInput.id : randomUUID();
     const ts = nowIso();
-    const { base, collections } = splitCollections(m, { ...parsed.data });
-    const row = flattenEmbedded(m, { id, ...base, created_at: ts, updated_at: ts });
-    const dbRow = encodeTemporal(m, row);
+    const parsedData = parsed.data;
+    const { base, collections } = splitCollections(m, { ...parsedData });
+    const data = encodeJson(m, encodeTemporal(m, flattenEmbedded(m, { ...base, created_at: ts, updated_at: ts })));
+    let id;
     await getEm()
         .fork()
         .transactional(async (tx) => {
-        await tx.upsert(entityName, dbRow);
+        const entity = tx.create(entityName, data);
+        await tx.flush();
+        id = entity.id;
         await writeCollections(tx, m, id, collections);
-        writeEvent(tx, ctx.actor, 'create', `${m.vault}/${m.module}`, id, null, { ...parsed.data, id });
+        writeEvent(tx, ctx.actor, 'create', `${m.vault}/${m.module}`, id, null, { ...parsedData, id });
     });
-    return { ...parsed.data, id, created_at: ts, updated_at: ts };
+    return { ...parsedData, id, created_at: ts, updated_at: ts };
 }
-// ─── UPDATE ───────────────────────────────────────────────────────────────────
 export async function updateRecord(m, entityName, id, input, ctx) {
     const parsed = buildZodObjectPartial(m).safeParse(input);
     if (!parsed.success)
@@ -102,16 +99,30 @@ export async function updateRecord(m, entityName, id, input, ctx) {
         const ts = nowIso();
         const { base, collections } = splitCollections(m, { ...parsed.data });
         const merged = { ...existing, ...base };
-        const dbRow = encodeTemporal(m, flattenEmbedded(m, { ...merged, updated_at: ts }));
+        const reqIssues = [];
+        for (const [key, f] of fieldEntries(m.fields)) {
+            if (f.virtual || f.required === true)
+                continue;
+            if (key.includes('__'))
+                continue;
+            if (!resolveFlag(f.required, merged))
+                continue;
+            const v = merged[key];
+            if (v == null || v === '' || (Array.isArray(v) && v.length === 0))
+                reqIssues.push({ field: key, code: 'required', path: [key] });
+        }
+        if (reqIssues.length)
+            throw new ValidationError(reqIssues);
+        const dbRow = encodeJson(m, encodeTemporal(m, flattenEmbedded(m, { ...merged, updated_at: ts })));
         await tx.upsert(entityName, dbRow);
         await writeCollections(tx, m, id, collections);
-        const after = { ...merged, ...collections, updated_at: ts };
+        const allCollections = await readCollections(tx, m, id);
+        const after = { ...merged, ...allCollections, updated_at: ts };
         writeEvent(tx, ctx.actor, 'update', `${m.vault}/${m.module}`, id, existing, after);
         result = after;
     });
     return result;
 }
-// ─── DELETE ───────────────────────────────────────────────────────────────────
 export async function deleteRecord(m, entityName, id, ctx) {
     await getEm()
         .fork()
@@ -125,4 +136,3 @@ export async function deleteRecord(m, entityName, id, ctx) {
         writeEvent(tx, ctx.actor, 'delete', `${m.vault}/${m.module}`, id, existing, null);
     });
 }
-//# sourceMappingURL=mutate.js.map

package/dist/plugin-discovery.d.ts

@@ -1,5 +1,5 @@
 import type { PluginManifest } from '@coffer-org/sdk/plugin';
-import type { PluginHooks } from './plugin-hooks.js';
+import type { PluginHooks } from './plugin-hooks.ts';
 export interface PluginAssetPaths {
     schema: string;
     web?: string;
@@ -10,9 +10,6 @@ export interface PluginAssetUrls {
     web?: string;
     css?: string;
 }
-/** Maps a plugin's published `coffer` asset paths to host-served URLs.
- *  The relative path's basename is fixed by convention (schema.js/web.js/web.css);
- *  the actual file is read from node_modules by the static handler. */
 export declare function resolveAssetUrls(id: string, coffer: PluginAssetPaths): PluginAssetUrls;
 export interface PluginAssetRecord {
     id: string;
@@ -24,13 +21,5 @@ export interface PluginAssetRecord {
     css?: string;
 }
 export declare function discoverPluginAssets(): Promise<PluginAssetRecord[]>;
-/** Усі знайдені плагіни. Порядок неважливий — composeRegistry резолвить за dependsOn. */
 export declare function discoverPlugins(): Promise<PluginManifest[]>;
-/**
- * Збирає серверні хуки наявних плагінів. Плагін із runtime-входом
- * (package.json `coffer.server` або `exports["./runtime"]`) може експортувати
- * `serverHooks: PluginHooks`. Імпорт — через ЗМІННИЙ специфікатор, тож tsc НЕ тягне
- * plugin-src у серверну програму (розрив циклу server↔плагіни).
- */
 export declare function loadServerHooks(): Promise<Record<string, PluginHooks>>;
-//# sourceMappingURL=plugin-discovery.d.ts.map

package/dist/plugin-discovery.js

@@ -1,8 +1,11 @@
-/**
- * Рантайм-виявлення плагінів: скан node_modules на @coffer-org/plugin-* та
- * coffer-plugin-*. Кожен пакет постачає PluginManifest (default-export schema-entry).
- * Один битий плагін логиться й пропускається — інстанс не падає (trust=none маркетплейс).
- */
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
 import { readdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
@@ -15,7 +18,6 @@ async function pkgNames(nm) {
         }
     }
     catch {
-        /* немає @coffer-скоупу — ок */
     }
     try {
         for (const d of await readdir(nm)) {
@@ -24,13 +26,9 @@ async function pkgNames(nm) {
         }
     }
     catch {
-        /* немає node_modules — ок */
     }
     return names;
 }
-/** Maps a plugin's published `coffer` asset paths to host-served URLs.
- *  The relative path's basename is fixed by convention (schema.js/web.js/web.css);
- *  the actual file is read from node_modules by the static handler. */
 export function resolveAssetUrls(id, coffer) {
     const base = `/plugins/${id}`;
     const out = { schema: `${base}/schema.js` };
@@ -50,7 +48,7 @@ export async function discoverPluginAssets() {
             if (!pkg.coffer?.schema)
                 continue;
             const spec = pathToFileURL(join(nm, name, pkg.coffer.schema)).href;
-            const manifest = (await import(spec)).default;
+            const manifest = (await import(__rewriteRelativeImportExtension(spec))).default;
             if (!manifest?.id)
                 continue;
             const urls = resolveAssetUrls(manifest.id, pkg.coffer);
@@ -75,23 +73,19 @@ async function loadManifest(nm, name) {
         const pkg = JSON.parse(await readFile(join(nm, name, 'package.json'), 'utf8'));
         const schemaRel = pkg?.coffer?.schema;
         const spec = schemaRel ? pathToFileURL(join(nm, name, schemaRel)).href : name;
-        const mod = (await import(spec));
+        const mod = (await import(__rewriteRelativeImportExtension(spec)));
         const manifest = mod.default;
         if (manifest && typeof manifest.id === 'string')
             return manifest;
-        console.warn(`[discovery] ${name}: немає валідного default-маніфесту, пропуск`);
+        console.warn(`[discovery] ${name}: no valid default manifest, skipping`);
         return null;
     }
     catch (e) {
-        console.error(`[discovery] ${name}: збій імпорту, пропуск — ${e.message}`);
+        console.error(`[discovery] ${name}: import failed, skipping — ${e.message}`);
         return null;
     }
 }
-/** Усі знайдені плагіни. Порядок неважливий — composeRegistry резолвить за dependsOn. */
 export async function discoverPlugins() {
-    // Скануємо node_modules коренем інстансу (cwd): сервер запускається з кореня,
-    // npm workspaces хостить пакети у корене́вий node_modules. Запуск із packages/server
-    // дивився б у локальний node_modules і не побачив би хостовані плагіни.
     const nm = join(process.cwd(), 'node_modules');
     const names = await pkgNames(nm);
     const manifests = [];
@@ -102,12 +96,6 @@ export async function discoverPlugins() {
     }
     return manifests;
 }
-/**
- * Збирає серверні хуки наявних плагінів. Плагін із runtime-входом
- * (package.json `coffer.server` або `exports["./runtime"]`) може експортувати
- * `serverHooks: PluginHooks`. Імпорт — через ЗМІННИЙ специфікатор, тож tsc НЕ тягне
- * plugin-src у серверну програму (розрив циклу server↔плагіни).
- */
 export async function loadServerHooks() {
     const nm = join(process.cwd(), 'node_modules');
     const names = await pkgNames(nm);
@@ -119,19 +107,18 @@ export async function loadServerHooks() {
             const hasRuntime = Boolean(serverRel) || Boolean(pkg?.exports?.['./runtime']);
             if (!hasRuntime)
                 continue;
-            const manifest = (await import(name)).default;
+            const manifest = (await import(__rewriteRelativeImportExtension(name))).default;
             const id = manifest?.id;
             if (!id)
                 continue;
             const spec = serverRel ? pathToFileURL(join(nm, name, serverRel)).href : `${name}/runtime`;
-            const mod = (await import(spec));
+            const mod = (await import(__rewriteRelativeImportExtension(spec)));
             if (mod.serverHooks)
                 hooks[id] = mod.serverHooks;
         }
         catch (e) {
-            console.error(`[discovery] ${name}: серверні хуки не завантажено — ${e.message}`);
+            console.error(`[discovery] ${name}: server hooks not loaded — ${e.message}`);
         }
     }
     return hooks;
 }
-//# sourceMappingURL=plugin-discovery.js.map