@coffer-org/server 3.3.0 → 4.0.0

package/dist/extend-table.js

@@ -4,14 +4,22 @@ import { encodeJsonAt } from "./mutate.js";
 import { encodeTemporalAt, decodeTemporalAt } from "./temporal.js";
 import { chunk } from "./batch.js";
 import { selectRows } from "./read-rows.js";
-import { injectParts, applyStoredParts } from "./part-injection.js";
+import { hasStoredPartWork } from "./part-injection.js";
+import { changedFields, runTriggers } from "./trigger-queue.js";
+import { getActiveRegistry } from "./registry-context.js";
 export function extendEntityName(e) {
     return `extend__${e.id}`;
 }
-function extendPartCtx(e, record) {
-    return { record, settings: {}, global: {}, meta: { library: 'extend', shelf: e.id } };
+function extendPartCtx(e, em, memo) {
+    return {
+        settings: {},
+        global: {},
+        meta: { library: 'extend', shelf: e.id },
+        ...(em ? { em } : {}),
+        ...(memo ? { memo } : {}),
+    };
 }
-export async function getExtendRecord(e, baseId, em) {
+export async function getExtendRecord(e, baseId, em, _memo) {
     const fork = em ?? getEm().fork();
     const name = extendEntityName(e);
     const [flat] = (await selectRows(fork, name, { base_id: baseId }, { limit: 1 }));
@@ -19,8 +27,7 @@ export async function getExtendRecord(e, baseId, em) {
         return undefined;
     const decoded = nestEmbeddedAt(e.fields, decodeTemporalAt(e.fields, flat));
     const collections = await readAt(fork, name, e.fields, baseId);
-    const record = { ...decoded, ...collections };
-    return injectParts(e.fields, record, extendPartCtx(e, record));
+    return { ...decoded, ...collections };
 }
 export async function getExtendRecords(e, baseIds, em) {
     const out = new Map();
@@ -39,15 +46,45 @@ export async function getExtendRecords(e, baseIds, em) {
     for (const flat of flats) {
         const id = Number(flat.base_id);
         const decoded = nestEmbeddedAt(e.fields, decodeTemporalAt(e.fields, flat));
-        const record = { ...decoded, ...(collectionsById.get(id) ?? {}) };
-        out.set(id, await injectParts(e.fields, record, extendPartCtx(e, record)));
+        out.set(id, { ...decoded, ...(collectionsById.get(id) ?? {}) });
     }
     return out;
 }
-export async function upsertExtendRecord(em, e, baseId, data) {
+async function storedExtendState(em, e, baseId) {
     const name = extendEntityName(e);
-    const withParts = await applyStoredParts(e.fields, data, extendPartCtx(e, data));
-    const { base, collections } = splitAt(e.fields, withParts);
+    const [flat] = (await selectRows(em, name, { base_id: baseId }, { limit: 1 }));
+    if (!flat)
+        return {};
+    const decoded = nestEmbeddedAt(e.fields, decodeTemporalAt(e.fields, flat));
+    return { ...decoded, ...(await readAt(em, name, e.fields, baseId)) };
+}
+export async function upsertExtendRecord(em, e, baseId, data, memo) {
+    const name = extendEntityName(e);
+    const needParts = hasStoredPartWork(e.fields);
+    let target;
+    let withParts;
+    if (needParts) {
+        const stored = await storedExtendState(em, e, baseId);
+        target = { ...stored, ...data };
+        const changed = changedFields(stored, target, e.fields);
+        const graph = getActiveRegistry().mutateGraph;
+        const seedAll = Object.keys(stored).length === 0;
+        withParts = await runTriggers(e.fields, target, changed, graph, `extend:${e.id}`, extendPartCtx(e, em, memo), {
+            seedAll,
+        });
+    }
+    else {
+        target = data;
+        withParts = data;
+    }
+    const write = {};
+    for (const [k, v] of Object.entries(withParts))
+        if (k in data || v !== target[k])
+            write[k] = v;
+    const { base, collections } = splitAt(e.fields, write);
+    for (const k of Object.keys(collections))
+        if (!(k in data))
+            delete collections[k];
     const flat = encodeJsonAt(e.fields, encodeTemporalAt(e.fields, flattenEmbeddedAt(e.fields, base)));
     await em.upsert(name, { base_id: baseId, ...flat });
     await writeAt(em, name, e.fields, baseId, collections);

package/dist/file-fields.js

@@ -87,38 +87,65 @@ export function dropUnchangedFileFields(m, input, stored) {
     }
     return out ?? input;
 }
+function normalizeFileValue(raw, field, path, issues) {
+    const parsed = jsonValue(raw);
+    const isArray = Array.isArray(parsed);
+    const items = (isArray ? parsed : [parsed]);
+    const out = [];
+    let failed = false;
+    for (const it of items) {
+        if (typeof it !== 'object' || it === null || typeof it.name !== 'string') {
+            issues.push({ field, code: 'file_not_uploaded', path });
+            failed = true;
+            continue;
+        }
+        const resolved = resolveEntry(it);
+        if (!resolved) {
+            issues.push({ field, code: 'file_not_uploaded', params: { name: it.name }, path });
+            failed = true;
+            continue;
+        }
+        out.push(resolved);
+    }
+    if (failed)
+        return null;
+    return { value: isArray ? out : out[0] };
+}
 function normalizeLevel(fields, data, path) {
     const issues = [];
     for (const [key, f] of fieldEntries(fields)) {
-        if (f.prim !== 'file')
-            continue;
         if (!(key in data))
             continue;
-        const raw = data[key];
-        if (raw == null || raw === '')
+        if (f.prim === 'file') {
+            const raw = data[key];
+            if (raw == null || raw === '')
+                continue;
+            const r = normalizeFileValue(raw, key, [...path, key], issues);
+            if (r)
+                data[key] = r.value;
+            continue;
+        }
+        if (!f.parts?.some((p) => p.meta.prim === 'file'))
             continue;
-        const parsed = jsonValue(raw);
-        const isArray = Array.isArray(parsed);
-        const items = (isArray ? parsed : [parsed]);
-        const out = [];
-        let failed = false;
-        for (const it of items) {
-            if (typeof it !== 'object' || it === null || typeof it.name !== 'string') {
-                issues.push({ field: key, code: 'file_not_uploaded', path: [...path, key] });
-                failed = true;
+        const obj = jsonValue(data[key]);
+        if (obj == null || typeof obj !== 'object' || Array.isArray(obj))
+            continue;
+        const row = obj;
+        let touched = false;
+        for (const p of f.parts) {
+            if (p.meta.prim !== 'file')
+                continue;
+            const raw = row[p.role];
+            if (raw == null || raw === '')
                 continue;
-            }
-            const resolved = resolveEntry(it);
-            if (!resolved) {
-                issues.push({ field: key, code: 'file_not_uploaded', params: { name: it.name }, path: [...path, key] });
-                failed = true;
+            const r = normalizeFileValue(raw, key, [...path, key, p.role], issues);
+            if (!r)
                 continue;
-            }
-            out.push(resolved);
+            row[p.role] = r.value;
+            touched = true;
         }
-        if (failed)
-            continue;
-        data[key] = isArray ? out : out[0];
+        if (touched)
+            data[key] = row;
     }
     for (const c of collectionGroups(fields)) {
         const rows = data[c.key];

package/dist/global-search.js

@@ -1,5 +1,5 @@
 import { textSearchKeys, titleKey, recordTitle, storageColumnsFor } from '@coffer-org/sdk/shelf';
-import { tokenize } from '@coffer-org/core/search';
+import { tokenize } from '@coffer-org/sdk/search';
 import { getLogger } from '@coffer-org/sdk/logger';
 import { getEm } from "./db.js";
 import { rowMatch } from "./records-api.js";

package/dist/http-errors.d.ts

@@ -0,0 +1,7 @@
+import type { FastifyInstance } from 'fastify';
+export interface HttpError {
+    code: number;
+    body: Record<string, unknown>;
+}
+export declare function httpErrorFor(e: unknown): HttpError | null;
+export declare function registerErrorHandler(app: FastifyInstance): void;

package/dist/http-errors.js

@@ -0,0 +1,24 @@
+import { ValidationError, NotFoundError } from "./mutate.js";
+import { SingleShelfError } from "./records-api.js";
+import { PartContractError } from "./part-errors.js";
+export function httpErrorFor(e) {
+    if (e instanceof ValidationError)
+        return { code: 422, body: { error: 'validation', issues: e.issues } };
+    if (e instanceof SingleShelfError)
+        return { code: 409, body: { error: 'single_shelf', message: e.message } };
+    if (e instanceof NotFoundError)
+        return { code: 404, body: { error: 'not_found' } };
+    if (e instanceof PartContractError)
+        return { code: 500, body: { error: 'part_contract', message: e.message } };
+    return null;
+}
+export function registerErrorHandler(app) {
+    app.setErrorHandler((error, req, reply) => {
+        const mapped = httpErrorFor(error);
+        if (!mapped)
+            return reply.send(error);
+        if (mapped.code >= 500)
+            req.log.error(error);
+        return reply.code(mapped.code).send(mapped.body);
+    });
+}

package/dist/index.js

@@ -11,11 +11,13 @@ import fastifyStatic from '@fastify/static';
 import { shelfTableName } from "./entity-schema.js";
 import { getEm, closeDb } from "./db.js";
 import { recordCounts } from "./counts.js";
-import { ValidationError, NotFoundError } from "./mutate.js";
+import { NotFoundError } from "./mutate.js";
+import { httpErrorFor, registerErrorHandler } from "./http-errors.js";
 import { resolveEmbed } from "./embed.js";
 import { resolveWithinHome, filterSort, listDir } from "./fs-list.js";
 import { initPlugins, teardownPlugins, readDisabled, purgePluginData, getPluginSettings, getPlugins, } from "./plugin-runtime.js";
 import { registerPluginsApi } from "./plugins-api.js";
+import { orchestratorDiagnostics } from "./orchestrator/index.js";
 import { registerPluginUserApi, registerPluginAdminApi } from "./plugin-user-api.js";
 import { registerAuthApi, resolveRequestUser, requireAdmin, PUBLIC_API_PATHS } from "./auth-api.js";
 import { registerMcpHttp } from "./mcp-http.js";
@@ -24,17 +26,18 @@ import { baseUrl } from "./public-url.js";
 import { discoverPluginAssets, discoverRuntime } from "./plugin-discovery.js";
 import { checkLatestVersion, resolveUpdateTarget, resolveAllUpdateTargets, resolveBaseTargets, resolveRuntimeTarget, runNpmInstall, } from "./plugin-updates.js";
 import { buildClientSchema } from "./schema-api.js";
-import { recordList, recordListPage, isPagedRequest, recordGet, recordCreate, recordUpdate, recordDelete, recordRestore, recordPurge, recordTrashList, MAX_PAGE, UnknownShelfError, ensureSingle, SingleShelfError, } from "./records-api.js";
+import { recordList, recordListPage, isPagedRequest, recordGet, recordCreate, recordUpdate, recordDelete, recordRestore, recordPurge, recordTrashList, MAX_PAGE, UnknownShelfError, FilterError, ensureSingle, } from "./records-api.js";
 import { showcaseList, showcaseListAll, showcaseCount, UnknownShowcaseError } from "./showcase-api.js";
 import { getActiveRegistry } from "./registry-context.js";
 import { maskTree, preserveTree } from "./field-masking.js";
 import { writePluginSettings } from "./settings-write.js";
+import { findSettingsGroup, settingsGroups } from "./settings-groups.js";
 import { rootLogger, getLogger } from "./log.js";
 import { uploadsDir } from "./uploads.js";
 import { mimeForName } from "./file-fields.js";
 import { verifyUploadTicket } from "./upload-ticket.js";
 import { setPluginState } from "./plugin-state.js";
-import { SEARCH_STATE_PLUGIN, SEARCH_CURSOR_KEY } from "./search-indexer.js";
+import { SEARCH_STATE_NAMESPACE, SEARCH_CURSOR_KEY } from "./search-indexer.js";
 import { globalSearch } from "./global-search.js";
 import { applySmartRanking, getRecordActivity, markRecordViewed, setRecordFavorite } from "./record-activity.js";
 import { tracksRecordActivity } from "./record-activity-policy.js";
@@ -117,6 +120,7 @@ app.post('/api/embed', async (req, reply) => {
         return reply.code(422).send({ error: 'unresolved' });
     return reply.send(rec);
 });
+registerErrorHandler(app);
 function key(library, shelf) {
     return `${library}/${shelf}`;
 }
@@ -125,13 +129,11 @@ async function guard(reply, fn) {
         return await fn();
     }
     catch (e) {
-        if (e instanceof ValidationError)
-            return reply.code(422).send({ error: 'validation', issues: e.issues });
-        if (e instanceof SingleShelfError)
-            return reply.code(409).send({ error: 'single_shelf', message: e.message });
-        if (e instanceof NotFoundError)
-            return reply.code(404).send({ error: 'not_found' });
-        app.log.error(e);
+        const mapped = httpErrorFor(e);
+        if (!mapped || mapped.code >= 500)
+            app.log.error(e);
+        if (mapped)
+            return reply.code(mapped.code).send(mapped.body);
         return reply.code(500).send({ error: 'internal' });
     }
 }
@@ -191,8 +193,6 @@ app.patch('/api/plugins/:id', async (req, reply) => {
     const p = plugins.find((x) => x.id === id);
     if (!p)
         return reply.code(404).send({ error: 'unknown_plugin' });
-    if (id === 'core')
-        return reply.code(400).send({ error: 'core_required' });
     const disabled = await readDisabled();
     if (!enabled) {
         const dependents = plugins.filter((x) => !disabled.has(x.id) && x.id !== id && x.dependsOn.includes(id));
@@ -215,7 +215,7 @@ app.patch('/api/plugins/:id', async (req, reply) => {
     }
     await fork.flush();
     if (enabled) {
-        await setPluginState(SEARCH_STATE_PLUGIN, SEARCH_CURSOR_KEY, '0');
+        await setPluginState(SEARCH_STATE_NAMESPACE, SEARCH_CURSOR_KEY, '0');
     }
     return { ok: true, restartRequired: true };
 });
@@ -227,8 +227,6 @@ app.delete('/api/plugins/:id/data', async (req, reply) => {
     const p = plugins.find((x) => x.id === id);
     if (!p)
         return reply.code(404).send({ error: 'unknown_plugin' });
-    if (id === 'core')
-        return reply.code(400).send({ error: 'core_required' });
     const disabled = await readDisabled();
     const dependents = plugins.filter((x) => !disabled.has(x.id) && x.id !== id && x.dependsOn.includes(id));
     if (dependents.length) {
@@ -286,14 +284,9 @@ app.post('/api/plugins/update-all', async (req, reply) => {
 app.post('/api/system/update', async (req, reply) => {
     if (!requireAdmin(req, reply))
         return;
-    const assets = await discoverPluginAssets();
     const runtime = await discoverRuntime();
-    const core = assets.find((a) => a.id === 'core');
-    const [coreLatest, runtimeLatest] = await Promise.all([
-        core && !core.local ? checkLatestVersion(core.packageName) : Promise.resolve(null),
-        runtime && !runtime.local ? checkLatestVersion(runtime.packageName) : Promise.resolve(null),
-    ]);
-    const targets = resolveBaseTargets(assets, runtime, coreLatest, runtimeLatest);
+    const runtimeLatest = runtime && !runtime.local ? await checkLatestVersion(runtime.packageName) : null;
+    const targets = resolveBaseTargets(runtime, runtimeLatest);
     if (targets.length === 0)
         return reply.code(400).send({ error: 'no_update_available' });
     const result = await runNpmInstall(targets.map((t) => `${t.packageName}@${t.to}`), process.cwd());
@@ -303,29 +296,30 @@ app.post('/api/system/update', async (req, reply) => {
     reply.send({ ok: true, updated: targets.map(({ id, from, to }) => ({ id, from, to })) });
     setTimeout(() => process.exit(0), 500);
 });
-app.get('/api/plugins/:id/settings', async (req, reply) => {
+app.post('/api/system/orchestrator-diagnostics', async (req, reply) => {
+    if (!requireAdmin(req, reply))
+        return;
+    reply.send(await orchestratorDiagnostics());
+});
+app.get('/api/settings', async () => (await settingsGroups()).map((g) => ({ id: g.id, label: g.label, fields: g.fields })));
+app.get('/api/settings/:id', async (req, reply) => {
     if (!requireAdmin(req, reply))
         return;
     const { id } = req.params;
-    const plugins = await getPlugins();
-    const p = plugins.find((x) => x.id === id);
-    if (!p || !p.settings || p.settings.fields.length === 0) {
+    const group = await findSettingsGroup(id);
+    if (!group)
         return reply.code(404).send({ error: 'no_settings' });
-    }
-    const row = await getPluginSettings(id);
-    return maskTree(p.settings.fields, row);
+    return maskTree(group.fields, await getPluginSettings(id));
 });
-app.put('/api/plugins/:id/settings', (req, reply) => {
+app.put('/api/settings/:id', (req, reply) => {
     if (!requireAdmin(req, reply))
         return;
     return guard(reply, async () => {
         const { id } = req.params;
-        const plugins = await getPlugins();
-        const p = plugins.find((x) => x.id === id);
-        if (!p || !p.settings || p.settings.fields.length === 0) {
+        const group = await findSettingsGroup(id);
+        if (!group)
             return reply.code(404).send({ error: 'no_settings' });
-        }
-        const row = await writePluginSettings(getEm().fork(), id, (req.body ?? {}), req.user.login, plugins);
+        const row = await writePluginSettings(getEm().fork(), id, (req.body ?? {}), req.user.login);
         return { ok: true, row };
     });
 });
@@ -445,6 +439,8 @@ app.get('/api/:library/:shelf', async (req, reply) => {
     catch (e) {
         if (e instanceof UnknownShelfError)
             return reply.code(404).send({ error: 'unknown_shelf' });
+        if (e instanceof FilterError)
+            return reply.code(400).send({ error: 'bad_filter', message: e.message });
         throw e;
     }
 });

package/dist/mcp-contract/client.d.ts

@@ -0,0 +1,24 @@
+export declare class ConnectionError extends Error {
+}
+export declare class NotFoundError extends Error {
+}
+export declare class ValidationError extends Error {
+    issues: unknown[];
+    constructor(issues: unknown[]);
+}
+export interface ListQuery {
+    folderId?: string;
+    limit?: number;
+    [field: string]: string | number | undefined;
+}
+export interface CofferClientApi {
+    getSchema(): Promise<unknown>;
+    listRecords(library: string, shelf: string, query?: ListQuery): Promise<unknown>;
+    getRecord(library: string, shelf: string, id: number): Promise<unknown>;
+    createRecord(library: string, shelf: string, fields: Record<string, unknown>): Promise<unknown>;
+    updateRecord(library: string, shelf: string, id: number, fields: Record<string, unknown>): Promise<unknown>;
+    deleteRecord(library: string, shelf: string, id: number): Promise<unknown>;
+    listTrash(): Promise<unknown>;
+    restoreRecord(library: string, shelf: string, id: number): Promise<unknown>;
+    purgeRecord(library: string, shelf: string, id: number): Promise<unknown>;
+}

package/dist/mcp-contract/client.js

@@ -0,0 +1,12 @@
+export class ConnectionError extends Error {
+}
+export class NotFoundError extends Error {
+}
+export class ValidationError extends Error {
+    issues;
+    constructor(issues) {
+        super('validation');
+        this.issues = issues;
+        this.name = 'ValidationError';
+    }
+}

package/dist/mcp-contract/schema.d.ts

@@ -0,0 +1,46 @@
+export interface ShelfIndexEntry {
+    library: string;
+    libraryLabel: string;
+    shelf: string;
+    label: string;
+}
+export interface FieldInfo {
+    key: string;
+    kind: string;
+    prim: string;
+    required: boolean;
+    relation?: {
+        library: string;
+        shelf: string;
+    };
+    options?: unknown[];
+    fields?: FieldInfo[];
+    multiple?: true;
+    derived?: true;
+    write?: string;
+}
+export declare const FILE_WRITE_HINT: string;
+export declare const SOURCE_WRITE_HINT: string;
+export declare const DERIVED_WRITE_HINT: string;
+export declare const serverOwnedPartsHint: (roles: string[]) => string;
+export interface ShelfDescription {
+    library: string;
+    shelf: string;
+    label: string;
+    fields: FieldInfo[];
+}
+interface SchemaClient {
+    getSchema(): Promise<unknown>;
+}
+export declare function flattenFields(items: unknown[]): FieldInfo[];
+export declare class SchemaCache {
+    private client;
+    private cached?;
+    constructor(client: SchemaClient);
+    refresh(): void;
+    private load;
+    index(): Promise<ShelfIndexEntry[]>;
+    describeShelf(library: string, shelf: string): Promise<ShelfDescription>;
+    private find;
+}
+export {};

package/dist/mcp-contract/schema.js

@@ -0,0 +1,90 @@
+export const FILE_WRITE_HINT = 'Uploaded file only: {"name":"<filename returned by POST /api/upload>"} ' +
+    '(or an array of those when the field is multiple). ' +
+    'A remote URL is rejected — the server stores files, not links. ' +
+    'To add one: call create_upload_ticket, POST the bytes to the absolute upload_url it returns with that ' +
+    'Bearer token, then write the returned name. mime and size are set by the server; ' +
+    'sending them changes nothing. To remove a file, drop its entry from the array ' +
+    '(or clear the field) — an existing entry cannot be edited in place.';
+export const SOURCE_WRITE_HINT = 'plain text — write the full content as a string. Content must be valid UTF-8 text; binary content is rejected. ' +
+    'Capped per field (default 256 KB) — content over the cap fails with source_too_large. ' +
+    'Read-only in the web UI (people can only replace it by uploading a file).';
+export const DERIVED_WRITE_HINT = 'Read-only — the server recomputes this field from other fields of the record on every write ' +
+    'and rejects any value sent for it. To change it, change what it is computed from.';
+export const serverOwnedPartsHint = (roles) => `Partly read-only — the server owns ${roles.map((r) => `\`${r}\``).join(', ')} in this value and ` +
+    `computes ${roles.length > 1 ? 'them' : 'it'} on every write. Send the other roles only; anything ` +
+    `sent for these is discarded, and a read returns the server's value.`;
+function serverOwnedRoles(t) {
+    const parts = t.parts ?? [];
+    return parts.filter((p) => p.mode === 'computedStored').map((p) => p.role);
+}
+function hasValue(el) {
+    const type = el?.type;
+    return type !== undefined && typeof type === 'object';
+}
+function hasChildren(el) {
+    return typeof el === 'object' && el !== null && Array.isArray(el.fields);
+}
+function isStorageGroup(el) {
+    return el.scope === 'nest';
+}
+export function flattenFields(items) {
+    const out = [];
+    const push = (key, t) => out.push({
+        key,
+        kind: t.kind,
+        prim: t.prim,
+        required: t.required,
+        ...(t.relation ? { relation: t.relation } : {}),
+        ...(t.options ? { options: t.options } : {}),
+        ...(t.prim === 'file' ? { write: FILE_WRITE_HINT } : {}),
+        ...(serverOwnedRoles(t).length ? { write: serverOwnedPartsHint(serverOwnedRoles(t)) } : {}),
+        ...(t.kind === 'source' ? { write: SOURCE_WRITE_HINT } : {}),
+        ...(t.derived ? { derived: true, write: DERIVED_WRITE_HINT } : {}),
+    });
+    for (const it of items) {
+        if (hasValue(it) && 'key' in it)
+            push(it.key, it.type);
+        else if (hasChildren(it) && isStorageGroup(it))
+            out.push({
+                key: it.key,
+                kind: 'group',
+                prim: 'group',
+                required: it.required === true,
+                ...(it.multiple ? { multiple: true } : {}),
+                fields: flattenFields(it.fields),
+            });
+        else if (hasChildren(it))
+            out.push(...flattenFields(it.fields));
+    }
+    return out;
+}
+export class SchemaCache {
+    client;
+    cached;
+    constructor(client) {
+        this.client = client;
+    }
+    refresh() {
+        this.cached = undefined;
+    }
+    async load(force = false) {
+        if (force || !this.cached)
+            this.cached = (await this.client.getSchema());
+        return this.cached;
+    }
+    async index() {
+        const libraries = await this.load();
+        return libraries.flatMap((v) => v.shelves.map((m) => ({ library: v.id, libraryLabel: v.label, shelf: m.shelf, label: m.label })));
+    }
+    async describeShelf(library, shelf) {
+        let m = this.find(await this.load(), library, shelf);
+        if (!m)
+            m = this.find(await this.load(true), library, shelf);
+        if (!m)
+            throw new Error(`unknown_shelf ${library}/${shelf}`);
+        return { library, shelf, label: m.label, fields: flattenFields(m.fields) };
+    }
+    find(libraries, library, shelf) {
+        return libraries.find((v) => v.id === library)?.shelves.find((m) => m.shelf === shelf);
+    }
+}

package/dist/mcp-contract/tools.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { type CofferClientApi } from './client.ts';
+import { SchemaCache } from './schema.ts';
+export interface ToolResult {
+    content: {
+        type: 'text';
+        text: string;
+    }[];
+    isError?: boolean;
+}
+export interface ToolDef {
+    name: string;
+    description: string;
+    inputSchema: z.ZodRawShape;
+    handler: (args: Record<string, unknown>) => Promise<ToolResult>;
+}
+export declare const LIST_DEFAULT_LIMIT = 25;
+export declare const LIST_MAX_LIMIT = 200;
+export declare function buildTools(client: CofferClientApi, cache: SchemaCache): ToolDef[];