@coffer-org/server 2.3.1 → 2.4.0

package/dist/embed-openai.d.ts

@@ -1,5 +1,19 @@
 export declare const EMBED_MODEL = "text-embedding-3-small";
 export declare const EMBED_DIM = 1024;
+export type EmbeddingFailureReason = 'billing' | 'auth' | 'rate_limit' | 'server' | 'network' | 'unknown';
+export declare class OpenAIEmbeddingError extends Error {
+    readonly status: number | null;
+    readonly code: string | null;
+    readonly reason: EmbeddingFailureReason;
+    constructor(args: {
+        status?: number | null;
+        code?: string | null;
+        detail?: string;
+        reason?: EmbeddingFailureReason;
+        cause?: unknown;
+    });
+}
+export declare function embeddingFailureMessage(error: unknown): string;
 export declare function embedBatch(texts: string[], apiKey: string, fetchImpl?: typeof fetch): Promise<{
     vectors: number[][];
     tokens: number;

package/dist/embed-openai.js

@@ -1,19 +1,78 @@
 const OPENAI_URL = 'https://api.openai.com/v1/embeddings';
 export const EMBED_MODEL = 'text-embedding-3-small';
 export const EMBED_DIM = 1024;
+export class OpenAIEmbeddingError extends Error {
+    status;
+    code;
+    reason;
+    constructor(args) {
+        const status = args.status ?? null;
+        const suffix = args.detail ? `: ${args.detail}` : '';
+        super(`openai embeddings${status == null ? '' : ` ${status}`}${suffix}`, { cause: args.cause });
+        this.name = 'OpenAIEmbeddingError';
+        this.status = status;
+        this.code = args.code ?? null;
+        this.reason = args.reason ?? classifyEmbeddingFailure(status, args.code, args.detail);
+    }
+}
+function parseErrorBody(body) {
+    try {
+        const value = JSON.parse(body);
+        const code = typeof value.error?.code === 'string' ? value.error.code : null;
+        const message = typeof value.error?.message === 'string' ? value.error.message : '';
+        if (code || message)
+            return { code, detail: message || code || 'request failed' };
+    }
+    catch {
+    }
+    return { code: null, detail: body.slice(0, 200) || 'request failed' };
+}
+function classifyEmbeddingFailure(status, code, detail) {
+    const marker = `${code ?? ''} ${detail ?? ''}`.toLowerCase();
+    if (status === 402 || /insufficient_quota|billing|payment_required|payment required|hard.?limit|quota exceeded/.test(marker))
+        return 'billing';
+    if (status === 401 || status === 403)
+        return 'auth';
+    if (status === 429 || /rate.?limit/.test(marker))
+        return 'rate_limit';
+    if (status != null && status >= 500)
+        return 'server';
+    return 'unknown';
+}
+export function embeddingFailureMessage(error) {
+    if (!(error instanceof OpenAIEmbeddingError))
+        return error instanceof Error ? error.message : String(error);
+    switch (error.reason) {
+        case 'billing':
+            return 'OpenAI billing or quota is unavailable. RAG indexing/search is paused; records are still saved and indexing will retry after billing is restored.';
+        case 'auth':
+            return 'The OpenAI API key was rejected. RAG indexing/search is unavailable; records are still saved.';
+        case 'rate_limit':
+            return 'OpenAI rate limit reached. RAG indexing/search will retry; records are still saved.';
+        default:
+            return `OpenAI embeddings are unavailable${error.status == null ? '' : ` (HTTP ${error.status})`}. RAG will retry; records are still saved.`;
+    }
+}
 export async function embedBatch(texts, apiKey, fetchImpl = fetch) {
     if (texts.length === 0)
         return { vectors: [], tokens: 0 };
     if (!apiKey)
         throw new Error('embeddings: missing API key (OPENAI_API_KEY)');
-    const res = await fetchImpl(OPENAI_URL, {
-        method: 'POST',
-        headers: { 'content-type': 'application/json', authorization: `Bearer ${apiKey}` },
-        body: JSON.stringify({ model: EMBED_MODEL, input: texts, dimensions: EMBED_DIM }),
-    });
+    let res;
+    try {
+        res = await fetchImpl(OPENAI_URL, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json', authorization: `Bearer ${apiKey}` },
+            body: JSON.stringify({ model: EMBED_MODEL, input: texts, dimensions: EMBED_DIM }),
+        });
+    }
+    catch (cause) {
+        throw new OpenAIEmbeddingError({ reason: 'network', detail: 'network request failed', cause });
+    }
     if (!res.ok) {
         const body = await res.text().catch(() => '');
-        throw new Error(`openai embeddings ${res.status}: ${body.slice(0, 200)}`);
+        const parsed = parseErrorBody(body);
+        throw new OpenAIEmbeddingError({ status: res.status, code: parsed.code, detail: parsed.detail });
     }
     const json = (await res.json());
     const vectors = [...json.data].sort((a, b) => a.index - b.index).map((d) => d.embedding);

package/dist/entity-schema.js

@@ -42,6 +42,7 @@ export function buildEntitySchema(m) {
         id: { type: 'integer', primary: true, autoincrement: true },
         created_at: { type: 'text' },
         updated_at: { type: 'text' },
+        deleted_at: { type: 'text', nullable: true },
     };
     addFieldProps(properties, m.fields, (f) => !f.required);
     const name = shelfTableName(m.library, m.shelf);

package/dist/index.js

@@ -24,7 +24,7 @@ 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, UnknownShelfError, } from "./records-api.js";
+import { recordList, recordListPage, isPagedRequest, recordGet, recordCreate, recordUpdate, recordDelete, recordRestore, recordPurge, recordTrashList, UnknownShelfError, } from "./records-api.js";
 import { maskTree, preserveTree } from "./field-masking.js";
 import { writePluginSettings } from "./settings-write.js";
 import { rootLogger, getLogger } from "./log.js";
@@ -363,6 +363,43 @@ function maskRecordRow(library, shelf, row) {
     }
     return out;
 }
+app.get('/api/trash', async (_req, reply) => {
+    const rows = await recordTrashList();
+    return rows.map((entry) => ({ ...entry, record: maskRecordRow(entry.library, entry.shelf, entry.record) }));
+});
+app.post('/api/trash/:library/:shelf/:id/restore', async (req, reply) => {
+    const { library, shelf, id } = req.params;
+    const rid = Number(id);
+    if (isNaN(rid))
+        return reply.code(400).send({ error: 'invalid_id' });
+    try {
+        await recordRestore(library, shelf, rid);
+        return { ok: true };
+    }
+    catch (e) {
+        if (e instanceof UnknownShelfError || e instanceof NotFoundError)
+            return reply.code(404).send({ error: 'not_found' });
+        throw e;
+    }
+});
+app.delete('/api/trash/:library/:shelf/:id', async (req, reply) => {
+    const { library, shelf, id } = req.params;
+    const rid = Number(id);
+    if (isNaN(rid))
+        return reply.code(400).send({ error: 'invalid_id' });
+    if (req.body?.confirmed !== true) {
+        return reply.code(400).send({ error: 'explicit_confirmation_required' });
+    }
+    try {
+        await recordPurge(library, shelf, rid);
+        return reply.code(204).send();
+    }
+    catch (e) {
+        if (e instanceof UnknownShelfError || e instanceof NotFoundError)
+            return reply.code(404).send({ error: 'not_found' });
+        throw e;
+    }
+});
 app.get('/api/:library/:shelf', async (req, reply) => {
     const { library, shelf } = req.params;
     const { _fields, _extends, limit, offset, ...query } = req.query;

package/dist/mcp-local.d.ts

@@ -14,4 +14,7 @@ export declare class LocalClient implements CofferClientApi {
     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-local.js

@@ -1,5 +1,5 @@
 import { ValidationError, NotFoundError } from '@coffer-org/mcp/client';
-import { recordList, recordListPage, recordGet, recordCreate, recordUpdate, recordDelete, UnknownShelfError, } from "./records-api.js";
+import { recordList, recordListPage, recordGet, recordCreate, recordUpdate, recordDelete, UnknownShelfError, recordTrashList, recordRestore, recordPurge, } from "./records-api.js";
 import { ValidationError as ServerValidationError } from "./mutate.js";
 import { buildClientSchema } from "./schema-api.js";
 export function mapError(e) {
@@ -63,4 +63,30 @@ export class LocalClient {
             mapError(e);
         }
     }
+    async listTrash() {
+        try {
+            return await recordTrashList();
+        }
+        catch (e) {
+            mapError(e);
+        }
+    }
+    async restoreRecord(library, shelf, id) {
+        try {
+            await recordRestore(library, shelf, id);
+            return null;
+        }
+        catch (e) {
+            mapError(e);
+        }
+    }
+    async purgeRecord(library, shelf, id) {
+        try {
+            await recordPurge(library, shelf, id);
+            return null;
+        }
+        catch (e) {
+            mapError(e);
+        }
+    }
 }

package/dist/mcp-tools.js

@@ -11,7 +11,7 @@ import { describeCondition } from '@coffer-org/sdk/condition';
 import { getEm } from "./db.js";
 import { getPluginSettings } from "./plugin-runtime.js";
 import { searchEmbeddings } from "./embeddings.js";
-import { embedOne } from "./embed-openai.js";
+import { embedOne, embeddingFailureMessage } from "./embed-openai.js";
 import { getLogger } from "./log.js";
 import { writePluginSettings, listSettings } from "./settings-write.js";
 import { ValidationError, NotFoundError } from "./mutate.js";
@@ -143,7 +143,7 @@ export async function collectMcpTools(opts = {}) {
                     return { content: [{ type: 'text', text: formatHits(hits) }] };
                 }
                 catch (e) {
-                    return fail(`Error: ${e.message}`);
+                    return fail(`RAG unavailable: ${embeddingFailureMessage(e)} Use the regular coffer tools (list_records/get_record) instead.`);
                 }
             },
         });
@@ -265,7 +265,9 @@ export async function buildDomainSections() {
         "some are collections (nested rows — an array). Extends add extra field-sets to a shelf's records, shown only when a " +
         'condition holds (the "when …" notes below); in a fetched record they sit under `_extends`. ' +
         'Read: list_libraries → describe_shelf → list_records/get_record. Write: create_record/update_record (call describe_shelf first); ' +
-        'to remove a record use delete_record — do not blank its fields.';
+        'delete_record moves a record to reversible trash — do not blank fields. Before editing, read the complete record and patch only requested fields. ' +
+        'For duplicates, read both records completely, compare fields/collections/extends/attachments, recommend the less complete record for trash, and offer a field-by-field merge first. ' +
+        'Use list_trash and restore_record for recovery; purge_record is irreversible and requires explicit confirmation.';
     const rules = (await collectPluginInstructions()).map(({ id, instructions }) => `## ${id}\n${instructions}`);
     const site = await frontendInstructions();
     return [
@@ -281,6 +283,7 @@ export function buildMcpInstructions(sections) {
         'Use the tools to read and write this data: call list_libraries to see what exists, describe_shelf before create_record/update_record, then list_records / get_record to read. When a search_records tool is available, use it for semantic lookup.',
         'The per-library notes below name the shelves and the rules — not every field. For exact field names, types, and which are required, call describe_shelf(library, shelf) rather than guessing from the notes.',
         'Record field values may be JSON-encoded (e.g. quantity {"value":2000,"unit":"ml"}) — parse them.',
+        'Action safety: read a complete record before editing or deleting it. update_record must be the smallest patch and must preserve unmentioned fields. delete_record moves the record to reversible trash; never blank fields to simulate deletion. For suspected duplicates, read both complete records, compare fields/collections/extends/attachments, identify the less complete record, and offer a field-by-field merge before moving anything to trash. Use list_trash/restore_record for recovery; purge_record is irreversible and requires explicit confirmation.',
         'File fields (file/document/audio/video/image/media/avatar/cover/poster) hold a file uploaded to this server, ' +
             'never a remote URL: {"name":"<filename from POST /api/upload>"}. Writing a URL is rejected. ' +
             'To store a picture found on the web, download it locally first, then create_upload_ticket → POST /api/upload → write the returned name. ' +

package/dist/mutate.d.ts

@@ -20,8 +20,14 @@ 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: ShelfDef, entityName: string, id: number): Promise<Record<string, unknown> | undefined>;
+export declare function listRecords(entityName: string, opts?: {
+    deleted?: 'active' | 'deleted' | 'all';
+}): Promise<Record<string, unknown>[]>;
+export declare function getRecord(m: ShelfDef, entityName: string, id: number, opts?: {
+    includeDeleted?: boolean;
+}): Promise<Record<string, unknown> | undefined>;
 export declare function createRecord(m: ShelfDef, entityName: string, input: unknown, ctx: MutateCtx, afterBase?: AfterBaseHook): Promise<Record<string, unknown>>;
 export declare function updateRecord(m: ShelfDef, entityName: string, id: number, input: unknown, ctx: MutateCtx, afterBase?: AfterBaseHook): Promise<Record<string, unknown>>;
-export declare function deleteRecord(m: ShelfDef, entityName: string, id: number, ctx: MutateCtx, afterBase?: AfterBaseHook): Promise<void>;
+export declare function deleteRecord(m: ShelfDef, entityName: string, id: number, ctx: MutateCtx): Promise<void>;
+export declare function restoreRecord(m: ShelfDef, entityName: string, id: number, ctx: MutateCtx, afterBase?: AfterBaseHook): Promise<Record<string, unknown>>;
+export declare function purgeRecord(m: ShelfDef, entityName: string, id: number, ctx: MutateCtx, afterBase?: AfterBaseHook): Promise<void>;

package/dist/mutate.js

@@ -50,14 +50,19 @@ function writeEvent(em, actor, op, type, recordId, before, after) {
         after: after == null ? null : JSON.stringify(after),
     });
 }
-export async function listRecords(entityName) {
+export async function listRecords(entityName, opts = {}) {
     const fork = getEm().fork();
-    const rows = await fork.findAll(entityName, { orderBy: { id: 'asc' } });
+    const deleted = opts.deleted ?? 'active';
+    const where = deleted === 'active' ? { deleted_at: null } : deleted === 'deleted' ? { deleted_at: { $ne: null } } : {};
+    const rows = await fork.findAll(entityName, { where, orderBy: { id: 'asc' } });
     return serialize(rows);
 }
-export async function getRecord(m, entityName, id) {
+export async function getRecord(m, entityName, id, opts = {}) {
     const fork = getEm().fork();
-    const row = await fork.findOne(entityName, { id });
+    const row = await fork.findOne(entityName, {
+        id,
+        ...(opts.includeDeleted ? {} : { deleted_at: null }),
+    });
     if (!row)
         return undefined;
     const flat = decodeTemporal(m, serialize(row));
@@ -148,11 +153,45 @@ export async function updateRecord(m, entityName, id, input, ctx, afterBase) {
     notifyRecordsChanged();
     return result;
 }
-export async function deleteRecord(m, entityName, id, ctx, afterBase) {
+export async function deleteRecord(m, entityName, id, ctx) {
     await getEm()
         .fork()
         .transactional(async (tx) => {
-        const found = await tx.findOne(entityName, { id });
+        const found = await tx.findOne(entityName, { id, deleted_at: null });
+        if (!found)
+            throw new NotFoundError();
+        const existing = serialize(found);
+        found.deleted_at = nowIso();
+        await tx.flush();
+        writeEvent(tx, ctx.actor, 'delete', `${m.library}/${m.shelf}`, id, existing, null);
+    });
+    notifyRecordsChanged();
+}
+export async function restoreRecord(m, entityName, id, ctx, afterBase) {
+    let result;
+    await getEm()
+        .fork()
+        .transactional(async (tx) => {
+        const found = await tx.findOne(entityName, { id, deleted_at: { $ne: null } });
+        if (!found)
+            throw new NotFoundError();
+        found.deleted_at = null;
+        await tx.flush();
+        const flat = decodeTemporal(m, serialize(found));
+        const nested = nestEmbedded(m, flat);
+        const collections = await readCollections(tx, m, id);
+        const _extends = afterBase ? await afterBase(tx, id) : undefined;
+        result = { ...nested, ...collections, ...(_extends ? { _extends } : {}) };
+        writeEvent(tx, ctx.actor, 'restore', `${m.library}/${m.shelf}`, id, null, result);
+    });
+    notifyRecordsChanged();
+    return result;
+}
+export async function purgeRecord(m, entityName, id, ctx, afterBase) {
+    await getEm()
+        .fork()
+        .transactional(async (tx) => {
+        const found = await tx.findOne(entityName, { id, deleted_at: { $ne: null } });
         if (!found)
             throw new NotFoundError();
         const existing = serialize(found);
@@ -160,7 +199,7 @@ export async function deleteRecord(m, entityName, id, ctx, afterBase) {
         if (afterBase)
             await afterBase(tx, id);
         tx.remove(found);
-        writeEvent(tx, ctx.actor, 'delete', `${m.library}/${m.shelf}`, id, existing, null);
+        writeEvent(tx, ctx.actor, 'purge', `${m.library}/${m.shelf}`, id, existing, null);
     });
     notifyRecordsChanged();
 }

package/dist/records-api.d.ts

@@ -12,6 +12,7 @@ export type RecordListOpts = {
     limit?: number;
     offset?: number;
     orderBy?: Record<string, 'ASC' | 'DESC'>;
+    deleted?: 'active' | 'deleted' | 'all';
 };
 export declare const MAX_PAGE = 500;
 export declare function coerceFilter(v: string, column: string): unknown;
@@ -21,14 +22,25 @@ export declare function rowMatch(mdef: ShelfDef, row: Record<string, unknown>, t
     score: number;
     snippet: string;
 } | null;
-export declare function recordCount(library: string, shelf: string, query?: RecordListQuery): Promise<number>;
+export declare function recordCount(library: string, shelf: string, query?: RecordListQuery, opts?: Pick<RecordListOpts, 'deleted'>): Promise<number>;
 export declare function recordList(library: string, shelf: string, query?: RecordListQuery, opts?: RecordListOpts): Promise<Record<string, unknown>[]>;
 export declare function isPagedRequest(limit?: string, offset?: string): boolean;
 export declare function recordListPage(library: string, shelf: string, query?: RecordListQuery, opts?: RecordListOpts): Promise<{
     rows: Record<string, unknown>[];
     total: number;
 }>;
-export declare function recordGet(library: string, shelf: string, id: number): Promise<Record<string, unknown> | null>;
+export declare function recordGet(library: string, shelf: string, id: number, opts?: {
+    includeDeleted?: boolean;
+}): Promise<Record<string, unknown> | null>;
 export declare function recordCreate(library: string, shelf: string, body: unknown, actor?: string): Promise<Record<string, unknown>>;
 export declare function recordUpdate(library: string, shelf: string, id: number, body: unknown, actor?: string): Promise<Record<string, unknown>>;
 export declare function recordDelete(library: string, shelf: string, id: number, actor?: string): Promise<void>;
+export declare function recordRestore(library: string, shelf: string, id: number, actor?: string): Promise<void>;
+export declare function recordPurge(library: string, shelf: string, id: number, actor?: string): Promise<void>;
+export interface TrashRecord {
+    library: string;
+    shelf: string;
+    label: string;
+    record: Record<string, unknown>;
+}
+export declare function recordTrashList(): Promise<TrashRecord[]>;

package/dist/records-api.js

@@ -1,13 +1,13 @@
 import { fieldMap, textSearchKeys, titleKey, recordTitle, listKeys, storageColumnsFor } from '@coffer-org/sdk/shelf';
 import { tokenize, matchScoreFolded, foldText } from '@coffer-org/core/search';
 import { serialize } from '@mikro-orm/core';
-import { getShelf, getExtendsFor } from "./registry-context.js";
+import { getActiveRegistry, getShelf, getExtendsFor } from "./registry-context.js";
 import { shelfTableName } from "./entity-schema.js";
 import { getExtendRecord, getExtendRecords } from "./extend-table.js";
 import { getEm } from "./db.js";
 import { decodeTemporal, dtStringToDate } from "./temporal.js";
 import { splitBody, saveExtends, deleteExtends, validateExtends, readExtends } from "./extend-io.js";
-import { createRecord, updateRecord, getRecord, deleteRecord } from "./mutate.js";
+import { createRecord, updateRecord, getRecord, deleteRecord, restoreRecord, purgeRecord } from "./mutate.js";
 export class UnknownShelfError extends Error {
 }
 export const MAX_PAGE = 500;
@@ -98,20 +98,29 @@ function buildWhere(m, filterParams) {
     }
     return where;
 }
-export async function recordCount(library, shelf, query = {}) {
+export async function recordCount(library, shelf, query = {}, opts = {}) {
     const { m, ename } = resolve(library, shelf);
     const { q: _q, ...filterParams } = query;
     const where = buildWhere(m, filterParams);
-    if (m.standalone === false && Object.keys(where).length === 0)
+    const deleted = opts.deleted ?? 'active';
+    if (deleted === 'active')
+        where.deleted_at = null;
+    else if (deleted === 'deleted')
+        where.deleted_at = { $ne: null };
+    if (m.standalone === false && Object.keys(filterParams).length === 0)
         return 0;
     return getEm().fork().count(ename, where);
 }
 export async function recordList(library, shelf, query = {}, opts = {}) {
-    const { view = 'full', extends: withExt = true } = opts;
+    const { view = 'full', extends: withExt = true, deleted = 'active' } = opts;
     const { m, ename } = resolve(library, shelf);
     const { q, ...filterParams } = query;
     const where = buildWhere(m, filterParams);
-    if (m.standalone === false && Object.keys(where).length === 0)
+    if (deleted === 'active')
+        where.deleted_at = null;
+    else if (deleted === 'deleted')
+        where.deleted_at = { $ne: null };
+    if (m.standalone === false && Object.keys(filterParams).length === 0)
         return [];
     const fork = getEm().fork();
     const tokens = typeof q === 'string' && q ? tokenize(q) : [];
@@ -157,14 +166,14 @@ export async function recordListPage(library, shelf, query = {}, opts = {}) {
         return { rows: all.slice(offset, offset + limit), total: all.length };
     }
     const rows = await recordList(library, shelf, query, { ...opts, orderBy, limit, offset });
-    const total = await recordCount(library, shelf, query);
+    const total = await recordCount(library, shelf, query, opts);
     return { rows, total };
 }
-export async function recordGet(library, shelf, id) {
+export async function recordGet(library, shelf, id, opts = {}) {
     const { m, ename } = resolve(library, shelf);
     if (m.standalone === false)
         return null;
-    const row = await getRecord(m, ename, id);
+    const row = await getRecord(m, ename, id, opts);
     if (!row)
         return null;
     return withExtends(row, library, shelf);
@@ -191,5 +200,23 @@ export async function recordUpdate(library, shelf, id, body, actor = 'gui') {
 }
 export async function recordDelete(library, shelf, id, actor = 'gui') {
     const { m, ename } = resolve(library, shelf);
-    await deleteRecord(m, ename, id, { actor }, (tx) => deleteExtends(tx, library, shelf, id));
+    await deleteRecord(m, ename, id, { actor });
+}
+export async function recordRestore(library, shelf, id, actor = 'gui') {
+    const { m, ename } = resolve(library, shelf);
+    await restoreRecord(m, ename, id, { actor }, (tx, recordId) => readExtends(tx, library, shelf, recordId));
+}
+export async function recordPurge(library, shelf, id, actor = 'gui') {
+    const { m, ename } = resolve(library, shelf);
+    await purgeRecord(m, ename, id, { actor }, (tx, recordId) => deleteExtends(tx, library, shelf, recordId));
+}
+export async function recordTrashList() {
+    const shelves = getActiveRegistry().shelves.filter((s) => s.standalone !== false);
+    const out = [];
+    for (const m of shelves) {
+        const rows = await recordList(m.library, m.shelf, {}, { view: 'full', extends: true, deleted: 'deleted' });
+        for (const record of rows)
+            out.push({ library: m.library, shelf: m.shelf, label: m.label, record });
+    }
+    return out.sort((a, b) => String(b.record.deleted_at ?? '').localeCompare(String(a.record.deleted_at ?? '')));
 }

package/dist/search-indexer.js

@@ -23,7 +23,7 @@ export async function indexSearchOnce(batch = DEFAULT_BATCH) {
         if (!library || !shelf)
             continue;
         const key = `${r.type}/${r.record_id}`;
-        if (r.op === 'delete') {
+        if (r.op === 'delete' || r.op === 'purge') {
             byRef.set(key, { shelf: r.type, recordId: r.record_id, op: 'delete', folded: '' });
             continue;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coffer-org/server",
-  "version": "2.3.1",
+  "version": "2.4.0",
   "type": "module",
   "engines": {
     "node": ">=24"