@coffer-org/server 3.4.0 → 4.0.0

package/dist/recompute-derived.js

@@ -1,60 +1,137 @@
 import { collectionGroups } from '@coffer-org/sdk/shelf';
-import { derivedEntries, applyDerived } from '@coffer-org/sdk/derive';
 import { applyStoredParts, hasStoredPartWork } from "./part-injection.js";
+import { extendEntityName } from "./extend-table.js";
 import { getEm } from "./db.js";
 import { selectRows } from "./read-rows.js";
-import { encodeJson } from "./mutate.js";
-import { encodeTemporal, decodeTemporal } from "./temporal.js";
-import { flattenEmbedded, nestEmbedded, readCollections } from "./collection-io.js";
-function sameValue(a, b) {
-    if (a instanceof Date && b instanceof Date)
-        return a.getTime() === b.getTime();
-    if (a instanceof Date || b instanceof Date)
-        return false;
-    return a === b;
-}
+import { encodeJson, encodeJsonAt } from "./mutate.js";
+import { encodeTemporal, decodeTemporal, encodeTemporalAt, decodeTemporalAt } from "./temporal.js";
+import { flattenEmbedded, nestEmbedded, readCollectionsWithMeta, flattenEmbeddedAt, nestEmbeddedAt, readAtWithMeta, } from "./collection-io.js";
+import { levelClockColumnsByOwner } from "./cache-clock.js";
+import { sameValue } from "./value-compare.js";
 function partCtx(m) {
     return { settings: {}, global: {}, meta: { library: m.library, shelf: m.shelf } };
 }
-function changedTopLevel(m, before, after) {
-    const collKeys = new Set(collectionGroups(m.fields).map((c) => c.key));
+function extendCtx(e) {
+    return { settings: {}, global: {}, meta: { library: 'extend', shelf: e.id } };
+}
+function changedKeys(fields, before, after) {
+    const collKeys = new Set(collectionGroups(fields).map((c) => c.key));
+    const clocksByOwner = levelClockColumnsByOwner(fields);
+    const clockKeys = new Set([...clocksByOwner.values()].flat());
     const out = {};
     for (const [k, v] of Object.entries(after)) {
-        if (collKeys.has(k))
+        if (collKeys.has(k) || clockKeys.has(k))
             continue;
         if (JSON.stringify(before[k] ?? null) !== JSON.stringify(v ?? null))
             out[k] = v;
     }
+    for (const [owner, cols] of clocksByOwner) {
+        if (!(owner in out))
+            continue;
+        for (const col of cols) {
+            if (after[col] !== undefined)
+                out[col] = after[col];
+        }
+    }
     return out;
 }
-export async function recomputeDerivedFields(m, entityName) {
-    const storedParts = hasStoredPartWork(m.fields);
-    if (derivedEntries(m.fields).length === 0 && !storedParts)
+async function recomputeCollectionRows(em, tablePrefix, fields, before, after, meta) {
+    let anyChanged = false;
+    for (const c of collectionGroups(fields)) {
+        const table = `${tablePrefix}__${c.key}`;
+        const childFields = c.group.fields;
+        const beforeRows = before[c.key] ?? [];
+        const afterRows = after[c.key] ?? [];
+        const metas = meta[c.key] ?? [];
+        for (let i = 0; i < beforeRows.length; i++) {
+            const rm = metas[i];
+            const b = beforeRows[i];
+            const a = afterRows[i];
+            if (!rm || !b || !a)
+                continue;
+            const patch = changedKeys(childFields, b, a);
+            if (Object.keys(patch).length > 0) {
+                const encodedPatch = encodeJsonAt(childFields, flattenEmbeddedAt(childFields, patch));
+                const encodedBefore = encodeJsonAt(childFields, flattenEmbeddedAt(childFields, b));
+                const dirty = {};
+                for (const [k, v] of Object.entries(encodedPatch)) {
+                    if (!sameValue(encodedBefore[k], v))
+                        dirty[k] = v;
+                }
+                if (Object.keys(dirty).length > 0) {
+                    await em.nativeUpdate(table, { id: rm.id }, dirty);
+                    anyChanged = true;
+                }
+            }
+            if (await recomputeCollectionRows(em, table, childFields, b, a, rm.nested))
+                anyChanged = true;
+        }
+    }
+    return anyChanged;
+}
+async function recomputeExtendRow(em, e, baseId) {
+    const table = extendEntityName(e);
+    const [flat] = (await selectRows(em, table, { base_id: baseId }, { limit: 1 }));
+    if (!flat)
+        return false;
+    const decoded = nestEmbeddedAt(e.fields, decodeTemporalAt(e.fields, flat));
+    const { collections, meta } = await readAtWithMeta(em, table, e.fields, baseId);
+    const hydrated = { ...decoded, ...collections };
+    const withParts = await applyStoredParts(e.fields, hydrated, extendCtx(e));
+    let changed = false;
+    const patch = changedKeys(e.fields, hydrated, withParts);
+    if (Object.keys(patch).length > 0) {
+        const encoded = encodeJsonAt(e.fields, encodeTemporalAt(e.fields, flattenEmbeddedAt(e.fields, patch)));
+        const dirty = {};
+        for (const [k, v] of Object.entries(encoded)) {
+            if (!sameValue(flat[k], v))
+                dirty[k] = v;
+        }
+        if (Object.keys(dirty).length > 0) {
+            await em.nativeUpdate(table, { base_id: baseId }, dirty);
+            changed = true;
+        }
+    }
+    if (await recomputeCollectionRows(em, table, e.fields, collections, withParts, meta))
+        changed = true;
+    return changed;
+}
+export async function recomputeDerivedFields(m, entityName, extends_ = []) {
+    const hasExtendWork = extends_.some((e) => hasStoredPartWork(e.fields));
+    if (!hasStoredPartWork(m.fields) && !hasExtendWork)
         return { scanned: 0, changed: 0 };
     const fork = getEm().fork();
     const rows = await selectRows(fork, entityName, {}, { orderBy: { id: 'asc' } });
-    let changed = 0;
+    const changedIds = new Set();
     for (const row of rows) {
         const id = row['id'];
         const flat = decodeTemporal(m, row);
         const nested = nestEmbedded(m, flat);
-        const collections = await readCollections(fork, m, id);
+        const { collections, meta } = await readCollectionsWithMeta(fork, m, id);
         const hydrated = { ...nested, ...collections };
-        const withParts = storedParts ? await applyStoredParts(m.fields, hydrated, partCtx(m)) : hydrated;
-        const partPatch = storedParts ? changedTopLevel(m, hydrated, withParts) : {};
-        const derived = await applyDerived(m.fields, withParts);
-        if (Object.keys(derived).length === 0 && Object.keys(partPatch).length === 0)
-            continue;
-        const encoded = encodeJson(m, encodeTemporal(m, flattenEmbedded(m, { ...partPatch, ...derived })));
-        const dirty = {};
-        for (const [k, v] of Object.entries(encoded)) {
-            if (!sameValue(row[k], v))
-                dirty[k] = v;
+        const withParts = await applyStoredParts(m.fields, hydrated, partCtx(m));
+        const partPatch = changedKeys(m.fields, hydrated, withParts);
+        if (Object.keys(partPatch).length > 0) {
+            const encoded = encodeJson(m, encodeTemporal(m, flattenEmbedded(m, partPatch)));
+            const dirty = {};
+            for (const [k, v] of Object.entries(encoded)) {
+                if (!sameValue(row[k], v))
+                    dirty[k] = v;
+            }
+            if (Object.keys(dirty).length > 0) {
+                await fork.nativeUpdate(entityName, { id }, dirty);
+                changedIds.add(id);
+            }
+        }
+        if (await recomputeCollectionRows(fork, entityName, m.fields, collections, withParts, meta)) {
+            changedIds.add(id);
+        }
+        for (const e of extends_) {
+            if (!hasStoredPartWork(e.fields))
+                continue;
+            if (await recomputeExtendRow(fork, e, id))
+                changedIds.add(id);
         }
-        if (Object.keys(dirty).length === 0)
-            continue;
-        await fork.nativeUpdate(entityName, { id }, dirty);
-        changed += 1;
     }
-    return { scanned: rows.length, changed };
+    return { scanned: rows.length, changed: changedIds.size };
 }

package/dist/records-api.js

@@ -1,5 +1,5 @@
-import { fieldMap, textSearchKeys, titleKey, recordTitle, listKeys, storageColumnsFor, magnitudeSub, } from '@coffer-org/sdk/shelf';
-import { tokenize, matchScoreFolded, foldText } from '@coffer-org/core/search';
+import { fieldMap, textSearchKeys, titleKey, recordTitle, listKeys, storageColumnsFor, magnitudeSub, resolveColumnKey, } from '@coffer-org/sdk/shelf';
+import { tokenize, matchScoreFolded, foldText } from '@coffer-org/sdk/search';
 import { getActiveRegistry, getShelf, getExtendsFor } from "./registry-context.js";
 import { selectRows } from "./read-rows.js";
 import { shelfTableName } from "./entity-schema.js";
@@ -10,6 +10,7 @@ import { splitBody, saveExtends, deleteExtends, validateExtends, readExtends } f
 import { createRecord, updateRecord, getRecord, deleteRecord, restoreRecord, purgeRecord } from "./mutate.js";
 import { newPartMemo } from "./part-injection.js";
 import { deleteRecordActivity } from "./record-activity.js";
+import { stripClockKeys } from "./cache-clock.js";
 export class UnknownShelfError extends Error {
 }
 export class SingleShelfError extends Error {
@@ -95,26 +96,19 @@ export class FilterError extends Error {
 function resolveFilterKey(m, fm, k) {
     const direct = fm[k];
     if (direct) {
-        if (direct.virtual)
-            return undefined;
         if (!direct.columns)
             return { column: k, type: direct.column };
         const sub = magnitudeSub(direct);
         if (sub === undefined)
-            throw new FilterError(`${m.library}/${m.shelf}: '${k}' is a composite whose parts are all computed or pinned — it owns no column to filter on`);
+            throw new FilterError(`${m.library}/${m.shelf}: '${k}' is a composite with no stored part — it owns no column to filter on`);
         return { column: `${k}__${sub}`, type: direct.columns[sub] };
     }
-    const cut = k.lastIndexOf('__');
-    if (cut <= 0)
+    const owner = resolveColumnKey(fm, k);
+    if (!owner)
         return undefined;
-    const base = fm[k.slice(0, cut)];
-    if (!base?.columns)
-        return undefined;
-    const part = k.slice(cut + 2);
-    const type = base.columns[part];
-    if (type === undefined)
-        throw new FilterError(`${m.library}/${m.shelf}: '${k}' names no part of composite '${k.slice(0, cut)}' (parts: ${Object.keys(base.columns).join(', ')})`);
-    return { column: k, type };
+    if (owner.kind === 'unknown-sub')
+        throw new FilterError(`${m.library}/${m.shelf}: '${k}' names no part of composite '${owner.key}' (parts: ${Object.keys(owner.field.columns).join(', ')})`);
+    return { column: k, type: owner.field.columns[owner.sub] };
 }
 function buildWhere(m, filterParams) {
     const where = {};
@@ -179,8 +173,12 @@ async function listRecords(library, shelf, query = {}, opts = {}) {
     let rows = await selectRows(fork, ename, where, findOpts);
     if (tokens.length > 0)
         rows = rows.filter((row) => rowMatch(m, row, tokens) !== null);
-    if (projected)
+    if (projected) {
         rows = rows.map((row) => pickCols(row, projected));
+    }
+    else {
+        rows = rows.map((row) => stripClockKeys(row));
+    }
     const decoded = rows.map((r) => decodeTemporal(m, r));
     if (!withExt)
         return decoded;

package/dist/registry-context.d.ts

@@ -1,4 +1,4 @@
-import type { Registry } from '@coffer-org/core/compose';
+import type { Registry } from '@coffer-org/sdk/compose';
 export declare function setActiveRegistry(reg: Registry): void;
 export declare function getActiveRegistry(): Registry;
 export declare const getShelf: Registry['getShelf'];

package/dist/registry-context.js

@@ -1,5 +1,8 @@
+import { buildMutateGraph } from '@coffer-org/sdk/mutate-graph';
 let active = null;
 export function setActiveRegistry(reg) {
+    if (!reg.mutateGraph)
+        reg.mutateGraph = buildMutateGraph(reg);
     active = reg;
 }
 function current() {

package/dist/search-index.js

@@ -1,5 +1,5 @@
 import { textSearchKeys, titleKey } from '@coffer-org/sdk/shelf';
-import { foldText } from '@coffer-org/core/search';
+import { foldText } from '@coffer-org/sdk/search';
 import { getLogger } from '@coffer-org/sdk/logger';
 import { getEm } from "./db.js";
 import { getDialect } from "./dialect.js";

package/dist/search-indexer.d.ts

@@ -1,4 +1,4 @@
-export declare const SEARCH_STATE_PLUGIN = "core";
+export declare const SEARCH_STATE_NAMESPACE = "system";
 export declare const SEARCH_CURSOR_KEY = "fts_last_event_id";
 export declare function indexSearchOnce(batch?: number): Promise<number>;
 export declare function startSearchIndexer(batch?: number): () => void;

package/dist/search-indexer.js

@@ -5,13 +5,13 @@ import { getShelf } from "./registry-context.js";
 import { onRecordsChanged } from "./index-signal.js";
 import { ftsAvailable, foldedTextFor, upsertSearchRow, deleteSearchRow } from "./search-index.js";
 const log = getLogger('search-indexer');
-export const SEARCH_STATE_PLUGIN = 'core';
+export const SEARCH_STATE_NAMESPACE = 'system';
 export const SEARCH_CURSOR_KEY = 'fts_last_event_id';
 const DEFAULT_BATCH = 5000;
 export async function indexSearchOnce(batch = DEFAULT_BATCH) {
     if (!ftsAvailable())
         return 0;
-    const last = Number((await getPluginState(SEARCH_STATE_PLUGIN, SEARCH_CURSOR_KEY)) ?? '0');
+    const last = Number((await getPluginState(SEARCH_STATE_NAMESPACE, SEARCH_CURSOR_KEY)) ?? '0');
     const rows = await listEventsSince(last, batch);
     if (rows.length === 0)
         return 0;
@@ -52,7 +52,7 @@ export async function indexSearchOnce(batch = DEFAULT_BATCH) {
             await upsertSearchRow(p.shelf, p.recordId, p.folded);
     }
     const lastId = rows[rows.length - 1].id;
-    await setPluginState(SEARCH_STATE_PLUGIN, SEARCH_CURSOR_KEY, String(lastId));
+    await setPluginState(SEARCH_STATE_NAMESPACE, SEARCH_CURSOR_KEY, String(lastId));
     log.debug(`indexed ${byRef.size} record(s) from ${rows.length} event(s), cursor → ${lastId}`);
     return rows.length;
 }

package/dist/settings-groups.d.ts

@@ -0,0 +1,14 @@
+import type { LayoutEl } from '@coffer-org/sdk/fields';
+import type { PluginManifest } from '@coffer-org/sdk/plugin';
+import { SYSTEM_SETTINGS_ID } from './system-settings.ts';
+export interface SettingsGroup {
+    id: string;
+    label: string;
+    fields: LayoutEl[];
+}
+export { SYSTEM_SETTINGS_ID };
+export declare function groupsFromPlugins(plugins: PluginManifest[]): SettingsGroup[];
+export declare function systemSettingsGroup(): SettingsGroup;
+export declare function groupsWithSystem(plugins: PluginManifest[]): SettingsGroup[];
+export declare function settingsGroups(): Promise<SettingsGroup[]>;
+export declare function findSettingsGroup(id: string): Promise<SettingsGroup | undefined>;

package/dist/settings-groups.js

@@ -0,0 +1,25 @@
+import { getPlugins } from "./plugin-runtime.js";
+import { SYSTEM_SETTINGS_ID, SYSTEM_SETTINGS } from "./system-settings.js";
+export { SYSTEM_SETTINGS_ID };
+export function groupsFromPlugins(plugins) {
+    return plugins
+        .filter((p) => p.settings && p.settings.fields.length > 0)
+        .map((p) => ({ id: p.id, label: p.settings.label, fields: p.settings.fields }));
+}
+export function systemSettingsGroup() {
+    return { id: SYSTEM_SETTINGS_ID, label: SYSTEM_SETTINGS.label, fields: SYSTEM_SETTINGS.fields };
+}
+export function groupsWithSystem(plugins) {
+    const fromPlugins = groupsFromPlugins(plugins);
+    const clash = fromPlugins.find((g) => g.id === SYSTEM_SETTINGS_ID);
+    if (clash) {
+        throw new Error(`[settings] a plugin declares settings under the reserved group id '${SYSTEM_SETTINGS_ID}'`);
+    }
+    return [systemSettingsGroup(), ...fromPlugins];
+}
+export async function settingsGroups() {
+    return groupsWithSystem(await getPlugins());
+}
+export async function findSettingsGroup(id) {
+    return (await settingsGroups()).find((g) => g.id === id);
+}

package/dist/settings-write.d.ts

@@ -9,10 +9,10 @@ export interface SettingsFieldInfo {
     options?: string[];
 }
 export declare function describeSettingsFields(fields: LayoutEl[]): SettingsFieldInfo[];
-export declare function buildSettingsBody(pluginId: string, fields: LayoutEl[], incoming: Record<string, unknown>, existing: Record<string, unknown>): Record<string, unknown>;
-export declare function writePluginSettings(em: EntityManager, pluginId: string, incoming: Record<string, unknown>, actor: string, plugins?: PluginManifest[]): Promise<Record<string, unknown>>;
-export declare function listSettings(plugins?: PluginManifest[]): Promise<{
-    plugin: string;
+export declare function buildSettingsBody(groupId: string, fields: LayoutEl[], incoming: Record<string, unknown>, existing: Record<string, unknown>, label?: string): Record<string, unknown>;
+export declare function writePluginSettings(em: EntityManager, groupId: string, incoming: Record<string, unknown>, actor: string, pluginsOverride?: PluginManifest[]): Promise<Record<string, unknown>>;
+export declare function listSettings(pluginsOverride?: PluginManifest[]): Promise<{
+    group: string;
     label: string;
     fields: SettingsFieldInfo[];
     values: Record<string, unknown>;

package/dist/settings-write.js

@@ -1,8 +1,9 @@
 import { fieldEntries, buildZodObject } from '@coffer-org/sdk/shelf';
 import { preserveTree, maskTree } from "./field-masking.js";
 import { ValidationError, NotFoundError, toIssue } from "./mutate.js";
-import { getPlugins, getPluginSettings } from "./plugin-runtime.js";
+import { getPluginSettings } from "./plugin-runtime.js";
 import { invalidatePublicUrlCache } from "./public-url.js";
+import { groupsFromPlugins, settingsGroups, findSettingsGroup, SYSTEM_SETTINGS_ID } from "./settings-groups.js";
 export function describeSettingsFields(fields) {
     return fieldEntries(fields).map(([key, f]) => ({
         key,
@@ -12,38 +13,35 @@ export function describeSettingsFields(fields) {
         ...(f.options ? { options: f.options.map((o) => o.value) } : {}),
     }));
 }
-function settingsShelf(pluginId, fields) {
-    return { library: '_settings', shelf: pluginId, label: `${pluginId}.plugin.label`, fields };
+function settingsShelf(groupId, fields, label = `${groupId}.plugin.label`) {
+    return { library: '_settings', shelf: groupId, label, fields };
 }
-export function buildSettingsBody(pluginId, fields, incoming, existing) {
+export function buildSettingsBody(groupId, fields, incoming, existing, label) {
     const body = preserveTree(fields, incoming, existing);
-    const parsed = buildZodObject(settingsShelf(pluginId, fields)).safeParse(body);
+    const parsed = buildZodObject(settingsShelf(groupId, fields, label)).safeParse(body);
     if (!parsed.success)
         throw new ValidationError(parsed.error.issues.map(toIssue));
     return parsed.data;
 }
-function withSettings(plugins) {
-    return plugins.filter((p) => p.settings && p.settings.fields.length > 0);
-}
-export async function writePluginSettings(em, pluginId, incoming, actor, plugins) {
-    const all = plugins ?? (await getPlugins());
-    const p = all.find((x) => x.id === pluginId);
-    if (!p || !p.settings || p.settings.fields.length === 0) {
+export async function writePluginSettings(em, groupId, incoming, actor, pluginsOverride) {
+    const group = pluginsOverride
+        ? groupsFromPlugins(pluginsOverride).find((g) => g.id === groupId)
+        : await findSettingsGroup(groupId);
+    if (!group)
         throw new NotFoundError();
-    }
-    const fields = p.settings.fields;
-    const existing = await getPluginSettings(pluginId);
-    const data = buildSettingsBody(pluginId, fields, incoming, existing);
-    const row = { plugin_id: pluginId, ...data };
-    await em.upsert(`_settings__${pluginId}`, row);
-    if (pluginId === 'core')
+    const fields = group.fields;
+    const existing = await getPluginSettings(groupId);
+    const data = buildSettingsBody(groupId, fields, incoming, existing, group.label);
+    const row = { plugin_id: groupId, ...data };
+    await em.upsert(`_settings__${groupId}`, row);
+    if (groupId === SYSTEM_SETTINGS_ID)
         invalidatePublicUrlCache();
     const masked = maskTree(fields, row);
     em.create('_Event', {
         ts: new Date().toISOString(),
         actor,
         op: 'settings',
-        type: pluginId,
+        type: groupId,
         record_id: null,
         before: JSON.stringify(maskTree(fields, existing)),
         after: JSON.stringify(masked),
@@ -51,13 +49,12 @@ export async function writePluginSettings(em, pluginId, incoming, actor, plugins
     await em.flush();
     return masked;
 }
-export async function listSettings(plugins) {
-    const all = withSettings(plugins ?? (await getPlugins()));
+export async function listSettings(pluginsOverride) {
+    const groups = pluginsOverride ? groupsFromPlugins(pluginsOverride) : await settingsGroups();
     const out = [];
-    for (const p of all) {
-        const fields = p.settings.fields;
-        const values = maskTree(fields, await getPluginSettings(p.id));
-        out.push({ plugin: p.id, label: p.settings.label, fields: describeSettingsFields(fields), values });
+    for (const g of groups) {
+        const values = maskTree(g.fields, await getPluginSettings(g.id));
+        out.push({ group: g.id, label: g.label, fields: describeSettingsFields(g.fields), values });
     }
     return out;
 }

package/dist/system-settings.d.ts

@@ -0,0 +1,3 @@
+import { type SettingsDef } from '@coffer-org/sdk/settings';
+export declare const SYSTEM_SETTINGS_ID = "system";
+export declare const SYSTEM_SETTINGS: SettingsDef;

package/dist/system-settings.js

@@ -0,0 +1,27 @@
+import { field } from '@coffer-org/sdk/fields';
+import { defineSettings } from '@coffer-org/sdk/settings';
+export const SYSTEM_SETTINGS_ID = 'system';
+export const SYSTEM_SETTINGS = defineSettings({
+    label: 'core.settings.label',
+    fields: {
+        publicUrl: field.string({
+            label: 'core.settings.publicUrl',
+            rules: { pattern: '^https?://[^/\\s]+/?$', messageKey: 'core.settings.publicUrlHint' },
+        }),
+        language: field.string({
+            label: 'core.settings.language',
+            default: 'uk',
+            strict: true,
+            view: { noSearch: true },
+            options: [
+                { value: 'uk', title: 'Українська' },
+                { value: 'ru', title: 'Русский' },
+                { value: 'en', title: 'English' },
+            ],
+        }),
+        agent_id: field.string({ label: 'core.settings.agent_id', strict: true, view: { noSearch: true } }),
+        access_password: field.password({ label: 'core.settings.access_password' }),
+        trigger_prefix: field.string({ label: 'core.settings.trigger_prefix' }),
+        reply_window: field.int({ label: 'core.settings.reply_window', default: 1800 }),
+    },
+});

package/dist/thread-store.d.ts

@@ -1,6 +1,7 @@
+export declare const SIDECAR_ROLES: readonly ["reasoning", "suggestions"];
 export interface StoredMsg {
     msgId: string;
-    role: 'user' | 'assistant' | 'reasoning';
+    role: 'user' | 'assistant' | 'reasoning' | 'suggestions';
     sender: string | null;
     text: string;
     attachments?: StoredAttachment[];
@@ -24,7 +25,7 @@ export declare function putThreadMessage(m: {
     connector: string;
     chatId: string;
     msgId: string;
-    role: 'user' | 'assistant' | 'reasoning';
+    role: 'user' | 'assistant' | 'reasoning' | 'suggestions';
     sender?: string | null;
     attachments?: StoredAttachment[];
     text: string;

package/dist/thread-store.js

@@ -1,4 +1,5 @@
 import { getEm } from "./db.js";
+export const SIDECAR_ROLES = ['reasoning', 'suggestions'];
 function toStored(r) {
     let attachments;
     if (r.attachments) {
@@ -49,12 +50,12 @@ export async function pruneThreadMessages(connector, cutoffTs) {
 }
 export async function listThreadMessages(connector, chatId, limit = 200) {
     const em = getEm().fork();
-    const visible = (await em.find('_ThreadMessage', { connector, chat_id: chatId, role: { $ne: 'reasoning' } }, { orderBy: { ts: 'desc', msg_id: 'desc' }, limit }));
+    const visible = (await em.find('_ThreadMessage', { connector, chat_id: chatId, role: { $nin: SIDECAR_ROLES } }, { orderBy: { ts: 'desc', msg_id: 'desc' }, limit }));
     const oldest = visible.at(-1)?.ts;
-    const reasoning = oldest === undefined
+    const sidecars = oldest === undefined
         ? []
-        : (await em.find('_ThreadMessage', { connector, chat_id: chatId, role: 'reasoning', ts: { $gte: oldest - 1 } }, { orderBy: { ts: 'desc', msg_id: 'desc' } }));
-    return [...visible, ...reasoning]
+        : (await em.find('_ThreadMessage', { connector, chat_id: chatId, role: { $in: SIDECAR_ROLES }, ts: { $gte: oldest - 1 } }, { orderBy: { ts: 'desc', msg_id: 'desc' } }));
+    return [...visible, ...sidecars]
         .sort((a, b) => b.ts - a.ts || (a.msg_id < b.msg_id ? 1 : a.msg_id > b.msg_id ? -1 : 0))
         .reverse()
         .map(toStored);
@@ -69,7 +70,7 @@ export async function listThreadChats(connector, chatIdPrefix) {
     const rows = (await em.find('_ThreadMessage', { connector, chat_id: { $gte: chatIdPrefix, $lt: upper } }, { orderBy: { ts: 'asc' } }));
     const byChat = new Map();
     for (const r of rows) {
-        if (r.role === 'reasoning')
+        if (SIDECAR_ROLES.includes(r.role))
             continue;
         const cur = byChat.get(r.chat_id);
         if (!cur) {

package/dist/trigger-queue.d.ts

@@ -0,0 +1,33 @@
+import { type LayoutEl } from '@coffer-org/sdk/fields';
+import type { MutateTarget } from '@coffer-org/sdk/mutate-path';
+import { type MutateGraph } from '@coffer-org/sdk/mutate-graph';
+import { type Row } from './compute-unit.ts';
+import { type PartCtx } from './part-injection.ts';
+export declare class TriggerQueueOverflowError extends Error {
+}
+export declare class TriggerRecordCapError extends Error {
+}
+export interface TouchedRecord {
+    library: string;
+    shelf: string;
+    id: number;
+    changed: string[];
+}
+interface CrossRecordState {
+    visited: Set<string>;
+    cap: number;
+    touched?: TouchedRecord[];
+}
+export interface ChangedField {
+    path: string[];
+}
+export declare function changedFields(before: Row, after: Row, fields: LayoutEl[]): ChangedField[];
+export declare function allUnitPaths(fields: LayoutEl[], scope?: string[]): string[][];
+export declare function runTriggers(fields: LayoutEl[], row: Row, changed: ChangedField[], graph: MutateGraph, shelfKey: string, ctx: PartCtx, opts?: {
+    seedAll?: boolean;
+    seedTargets?: MutateTarget[];
+    crossRecordState?: CrossRecordState;
+    recordCap?: number;
+    touched?: TouchedRecord[];
+}): Promise<Row>;
+export {};