@coffer-org/server 3.3.0 → 4.0.0

package/dist/plugin-runtime.js

@@ -1,4 +1,4 @@
-import { composeRegistry } from '@coffer-org/core/compose';
+import { composeRegistry } from '@coffer-org/sdk/compose';
 import { getLogger } from '@coffer-org/sdk/logger';
 import { initDb, getOrm, getEm } from "./db.js";
 import { syncSchema } from "./schema-sync.js";
@@ -6,13 +6,15 @@ import { systemEntities, buildPluginEntities, shelfTableName } from "./entity-sc
 import { pluginHooks, pluginCtx, HttpError } from "./plugin-hooks.js";
 import { discoverPlugins, loadServerHooks } from "./plugin-discovery.js";
 import { selectRows } from "./read-rows.js";
-import { runMigrations, assertSafeRequired, renameSystemShelfKey } from "./migrations.js";
+import { runMigrations, assertSafeRequired, runSystemMigrations } from "./migrations.js";
 import { runSeeds } from "./seeds.js";
 import { setActiveRegistry } from "./registry-context.js";
 import { migrateEmbeddingVectorsToBlob } from "./embeddings.js";
 import { ensureSearchTable } from "./search-index.js";
 import { startScheduler, stopScheduler } from "./background-scheduler.js";
 import { startSearchIndexer, indexSearchOnce } from "./search-indexer.js";
+import { startOrchestrator, stopOrchestrator, orchestratorStartersTask } from "./orchestrator/index.js";
+import { SYSTEM_SETTINGS_ID, SYSTEM_SETTINGS } from "./system-settings.js";
 const log = getLogger('plugins');
 let stopSearchIndexer;
 let _plugins = null;
@@ -22,9 +24,7 @@ export async function getPlugins() {
 export async function readDisabled() {
     const fork = getEm().fork();
     const rows = await fork.find('_Plugin', { enabled: 0 });
-    const disabled = new Set(rows.map((r) => r.id));
-    disabled.delete('core');
-    return disabled;
+    return new Set(rows.map((r) => r.id));
 }
 let _disabled = null;
 export function getDisabled() {
@@ -33,10 +33,10 @@ export function getDisabled() {
         throw e;
     }));
 }
-export async function getPluginSettings(pluginId) {
+export async function getPluginSettings(groupId) {
     try {
         const fork = getEm().fork();
-        const [row] = await selectRows(fork, `_settings__${pluginId}`, { plugin_id: pluginId }, { limit: 1 });
+        const [row] = await selectRows(fork, `_settings__${groupId}`, { plugin_id: groupId }, { limit: 1 });
         if (!row)
             return {};
         return row;
@@ -61,6 +61,12 @@ export async function requireSettings(pluginId, keys) {
     }
     return out;
 }
+function systemSettingsGroupInput() {
+    return { id: SYSTEM_SETTINGS_ID, fields: SYSTEM_SETTINGS.fields };
+}
+async function composeAll(disabled) {
+    return composeRegistry(await getPlugins(), { disabled, settingsGroups: [systemSettingsGroupInput()] });
+}
 async function seedPluginRows() {
     const fork = getEm().fork();
     const existing = new Set((await fork.find('_Plugin', {})).map((r) => r.id));
@@ -74,8 +80,9 @@ async function seedPluginRows() {
 }
 export async function initStorage() {
     await initDb(systemEntities);
-    await renameSystemShelfKey(getEm().fork());
+    await runSystemMigrations(getEm().fork());
     await syncSchema();
+    await runSystemMigrations(getEm().fork());
     await migrateEmbeddingVectorsToBlob();
     await getEm().fork().getConnection().execute('DROP TABLE IF EXISTS "_folders"');
     await seedPluginRows();
@@ -98,11 +105,12 @@ export async function initStorage() {
 }
 export async function initPlugins() {
     const disabled = await initStorage();
-    const reg = composeRegistry(await getPlugins(), { disabled });
+    const reg = await composeAll(disabled);
     setActiveRegistry(reg);
     Object.assign(pluginHooks, await loadServerHooks());
     await runSeeds({ em: getEm().fork(), plugins: reg.order, hooks: pluginHooks });
-    const bgTasks = [];
+    startOrchestrator();
+    const bgTasks = [orchestratorStartersTask];
     for (const p of reg.order) {
         const h = pluginHooks[p.id];
         try {
@@ -139,7 +147,7 @@ export async function teardownPlugins() {
     stopScheduler();
     Object.assign(pluginHooks, await loadServerHooks());
     const disabled = await readDisabled();
-    const reg = composeRegistry(await getPlugins(), { disabled });
+    const reg = await composeAll(disabled);
     for (const p of [...reg.order].reverse()) {
         const h = pluginHooks[p.id];
         if (!h?.teardown)
@@ -152,6 +160,7 @@ export async function teardownPlugins() {
             log.warn(`${p.id}: teardown ✗ ${e.message}`);
         }
     }
+    stopOrchestrator();
 }
 export async function teardownPlugin(id) {
     const h = pluginHooks[id];
@@ -185,6 +194,7 @@ export async function purgePluginData(p, actor) {
         .transactional(async (tx) => {
         const now = new Date().toISOString();
         await tx.nativeDelete('_Migration', { plugin_id: p.id });
+        await tx.nativeDelete('_MigrationOp', { plugin_id: p.id });
         await tx.nativeDelete('_Seed', { plugin_id: p.id });
         const row = await tx.findOne('_Plugin', { id: p.id });
         if (row)

package/dist/plugin-updates.d.ts

@@ -18,11 +18,11 @@ export interface AllUpdateTarget {
     to: string;
 }
 export declare function resolveAllUpdateTargets(assets: PluginAssetRecord[], latestById: Map<string, string | null>): AllUpdateTarget[];
-export declare function resolveBaseTargets(assets: PluginAssetRecord[], runtime: {
+export declare function resolveBaseTargets(runtime: {
     packageName: string;
     installedVersion: string;
     local: boolean;
-} | null, coreLatest: string | null, runtimeLatest: string | null): AllUpdateTarget[];
+} | null, runtimeLatest: string | null): AllUpdateTarget[];
 export interface RuntimeUpdateTarget {
     packageName: string;
     from: string;

package/dist/plugin-updates.js

@@ -1,8 +1,8 @@
 import { execFile } from 'node:child_process';
-import { isNewerVersion } from '@coffer-org/core/version';
+import { isNewerVersion } from '@coffer-org/sdk/version';
 import { getPluginState, setPluginState } from "./plugin-state.js";
 const TTL_MS = 60 * 60 * 1000;
-const STATE_PLUGIN = 'core';
+const STATE_NAMESPACE = 'system';
 const stateKey = (pkgName) => `update-check:${pkgName}`;
 function readCache(raw) {
     if (!raw)
@@ -18,7 +18,7 @@ export async function checkLatestVersion(pkgName, opts = {}) {
     const key = stateKey(pkgName);
     let cached = null;
     try {
-        cached = readCache(await getPluginState(STATE_PLUGIN, key));
+        cached = readCache(await getPluginState(STATE_NAMESPACE, key));
         if (!opts.force && cached && Date.now() - cached.checkedAt < TTL_MS)
             return cached.latestVersion;
         const res = await fetch(`https://registry.npmjs.org/${pkgName}/latest`, { signal: AbortSignal.timeout(5000) });
@@ -27,7 +27,7 @@ export async function checkLatestVersion(pkgName, opts = {}) {
         const data = (await res.json());
         if (!data.version)
             return cached?.latestVersion ?? null;
-        await setPluginState(STATE_PLUGIN, key, JSON.stringify({ latestVersion: data.version, checkedAt: Date.now() }));
+        await setPluginState(STATE_NAMESPACE, key, JSON.stringify({ latestVersion: data.version, checkedAt: Date.now() }));
         return data.version;
     }
     catch {
@@ -51,15 +51,9 @@ export function resolveAllUpdateTargets(assets, latestById) {
         return [{ id: rec.id, packageName: rec.packageName, from: rec.version, to: latest }];
     });
 }
-export function resolveBaseTargets(assets, runtime, coreLatest, runtimeLatest) {
-    const core = assets.find((a) => a.id === 'core');
+export function resolveBaseTargets(runtime, runtimeLatest) {
     const rt = resolveRuntimeTarget(runtime, runtimeLatest);
-    return [
-        ...(core && !core.local && coreLatest && isNewerVersion(coreLatest, core.version)
-            ? [{ id: 'core', packageName: core.packageName, from: core.version, to: coreLatest }]
-            : []),
-        ...(rt ? [{ id: 'runtime', packageName: rt.packageName, from: rt.from, to: rt.to }] : []),
-    ];
+    return rt ? [{ id: 'runtime', packageName: rt.packageName, from: rt.from, to: rt.to }] : [];
 }
 export function resolveRuntimeTarget(runtime, latestVersion) {
     if (!runtime || runtime.local)

package/dist/public-url.js

@@ -1,4 +1,5 @@
 import { getPluginSettings } from "./plugin-runtime.js";
+import { SYSTEM_SETTINGS_ID } from "./system-settings.js";
 const CACHE_TTL_MS = 30_000;
 let cached = null;
 export function invalidatePublicUrlCache() {
@@ -12,7 +13,7 @@ async function configuredBase() {
         return cached.value;
     let value = '';
     try {
-        value = normalize((await getPluginSettings('core'))['publicUrl']);
+        value = normalize((await getPluginSettings(SYSTEM_SETTINGS_ID))['publicUrl']);
     }
     catch {
         value = '';

package/dist/recompute-derived.d.ts

@@ -1,6 +1,7 @@
 import type { ShelfDef } from '@coffer-org/sdk/shelf';
+import type { ExtendDef } from '@coffer-org/sdk/extend';
 export interface RecomputeResult {
     scanned: number;
     changed: number;
 }
-export declare function recomputeDerivedFields(m: ShelfDef, entityName: string): Promise<RecomputeResult>;
+export declare function recomputeDerivedFields(m: ShelfDef, entityName: string, extends_?: ExtendDef[]): Promise<RecomputeResult>;

package/dist/recompute-derived.js

@@ -1,40 +1,137 @@
-import { derivedEntries, applyDerived } from '@coffer-org/sdk/derive';
+import { collectionGroups } from '@coffer-org/sdk/shelf';
+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)
+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 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) || 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;
+}
+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;
-    return a === b;
+    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) {
-    if (derivedEntries(m.fields).length === 0)
+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 derived = await applyDerived(m.fields, { ...nested, ...collections });
-        if (Object.keys(derived).length === 0)
-            continue;
-        const encoded = encodeJson(m, encodeTemporal(m, flattenEmbedded(m, derived)));
-        const dirty = {};
-        for (const [k, v] of Object.entries(encoded)) {
-            if (!sameValue(row[k], v))
-                dirty[k] = v;
+        const { collections, meta } = await readCollectionsWithMeta(fork, m, id);
+        const hydrated = { ...nested, ...collections };
+        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.d.ts

@@ -1,4 +1,5 @@
 import type { ShelfDef } from '@coffer-org/sdk/shelf';
+import { type PartMemo } from './part-injection.ts';
 export declare class UnknownShelfError extends Error {
 }
 export declare class SingleShelfError extends Error {
@@ -20,12 +21,15 @@ export type RecordListOpts = {
 };
 export declare const MAX_PAGE = 500;
 export declare function coerceFilter(v: string, column: string): unknown;
-export declare function withExtends(record: Record<string, unknown>, library: string, shelf: string): Promise<Record<string, unknown>>;
+export declare function withExtends(record: Record<string, unknown>, library: string, shelf: string, memo?: PartMemo): Promise<Record<string, unknown>>;
 export declare function withExtendsMany(rows: Record<string, unknown>[], library: string, shelf: string): Promise<Record<string, unknown>[]>;
 export declare function rowMatch(mdef: ShelfDef, row: Record<string, unknown>, tokens: string[]): {
     score: number;
     snippet: string;
 } | null;
+export declare class FilterError extends Error {
+    constructor(message: string);
+}
 export declare function recordCount(library: string, shelf: string, query?: RecordListQuery, opts?: Pick<RecordListOpts, 'deleted' | 'where'>): 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;

package/dist/records-api.js

@@ -1,5 +1,5 @@
-import { fieldMap, textSearchKeys, titleKey, recordTitle, listKeys, storageColumnsFor } 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";
@@ -8,7 +8,9 @@ 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, 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 {
@@ -42,13 +44,13 @@ export function coerceFilter(v, column) {
         return dtStringToDate(v);
     return v;
 }
-export async function withExtends(record, library, shelf) {
+export async function withExtends(record, library, shelf, memo) {
     const matchedExtends = getExtendsFor(library, shelf);
     if (!matchedExtends.length)
         return record;
     const _extends = {};
     await Promise.all(matchedExtends.map(async (e) => {
-        _extends[e.id] = (await getExtendRecord(e, record.id)) ?? null;
+        _extends[e.id] = (await getExtendRecord(e, record.id, undefined, memo)) ?? null;
     }));
     return { ...record, _extends };
 }
@@ -85,15 +87,38 @@ export function rowMatch(mdef, row, tokens) {
     const snippet = raw.length > 120 ? raw.slice(0, 120) + '…' : raw;
     return { score, snippet };
 }
+export class FilterError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'FilterError';
+    }
+}
+function resolveFilterKey(m, fm, k) {
+    const direct = fm[k];
+    if (direct) {
+        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 with no stored part — it owns no column to filter on`);
+        return { column: `${k}__${sub}`, type: direct.columns[sub] };
+    }
+    const owner = resolveColumnKey(fm, k);
+    if (!owner)
+        return undefined;
+    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 = {};
     const fm = fieldMap(m.fields);
     for (const [k, v] of Object.entries(filterParams)) {
         if (k === 'id' || v === undefined)
             continue;
-        const fieldDef = fm[k];
-        if (fieldDef && !fieldDef.virtual)
-            where[k] = coerceFilter(String(v), fieldDef.column);
+        const target = resolveFilterKey(m, fm, k);
+        if (target)
+            where[target.column] = coerceFilter(String(v), target.type);
     }
     if (filterParams['id']) {
         const ids = String(filterParams['id'])
@@ -148,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;
@@ -197,11 +226,12 @@ async function createOne(library, shelf, body, actor = 'gui') {
     const { m, ename } = resolve(library, shelf);
     const { base, extData } = splitBody(body);
     validateExtends(library, shelf, extData);
+    const memo = newPartMemo();
     const row = await createRecord(m, ename, base, { actor }, async (tx, id) => {
-        await saveExtends(tx, library, shelf, id, extData);
-        return readExtends(tx, library, shelf, id);
+        await saveExtends(tx, library, shelf, id, extData, memo);
+        return readExtends(tx, library, shelf, id, memo);
     });
-    return withExtends(row, library, shelf);
+    return withExtends(row, library, shelf, memo);
 }
 export async function recordCreate(library, shelf, body, actor = 'gui') {
     const { m } = resolve(library, shelf);
@@ -238,11 +268,12 @@ export async function recordUpdate(library, shelf, id, body, actor = 'gui') {
     const { m, ename } = resolve(library, shelf);
     const { base, extData } = splitBody(body);
     validateExtends(library, shelf, extData);
+    const memo = newPartMemo();
     const row = await updateRecord(m, ename, id, base, { actor }, async (tx) => {
-        await saveExtends(tx, library, shelf, id, extData);
-        return readExtends(tx, library, shelf, id);
+        await saveExtends(tx, library, shelf, id, extData, memo);
+        return readExtends(tx, library, shelf, id, memo);
     });
-    return withExtends(row, library, shelf);
+    return withExtends(row, library, shelf, memo);
 }
 export async function recordDelete(library, shelf, id, actor = 'gui') {
     const { m, ename } = resolve(library, shelf);
@@ -252,7 +283,8 @@ export async function recordDelete(library, shelf, id, actor = 'gui') {
 }
 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));
+    const memo = newPartMemo();
+    await restoreRecord(m, ename, id, { actor }, (tx, recordId) => readExtends(tx, library, shelf, recordId, memo));
 }
 export async function recordPurge(library, shelf, id, actor = 'gui') {
     const { m, ename } = resolve(library, shelf);

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/rename-guard.d.ts

@@ -0,0 +1 @@
+export declare function disableColumnRenameDetection(): void;

package/dist/rename-guard.js

@@ -0,0 +1,9 @@
+import { SchemaComparator } from '@mikro-orm/sqlite';
+let applied = false;
+export function disableColumnRenameDetection() {
+    if (applied)
+        return;
+    SchemaComparator.prototype['detectColumnRenamings'] = function noop() {
+    };
+    applied = true;
+}

package/dist/schema-sync.js

@@ -1,4 +1,41 @@
-import { getOrm } from "./db.js";
+import { getOrm, getEm } from "./db.js";
+import { introspectAllColumns, isColumnHandedOver } from "./migrations.js";
+import { getLogger } from '@coffer-org/sdk/logger';
+const log = getLogger('schema-sync');
+const q = (id) => `"${id.replace(/"/g, '""')}"`;
+async function warnAboutColumnsToBeDropped() {
+    try {
+        const orm = getOrm();
+        const em = getEm().fork();
+        const metas = [...orm.getMetadata().getAll().values()].filter((m) => !m.virtual && !m.pivotTable && m.tableName);
+        const live = await introspectAllColumns(em, [...new Set(metas.map((m) => m.tableName))]);
+        for (const meta of metas) {
+            const tableName = meta.tableName;
+            const columns = live.get(tableName);
+            if (!columns)
+                continue;
+            const known = new Set();
+            for (const prop of meta.props)
+                for (const f of prop.fieldNames ?? [])
+                    known.add(f);
+            const droppable = [...columns].filter((c) => !known.has(c) && !isColumnHandedOver(tableName, c));
+            if (!droppable.length)
+                continue;
+            const conn = em.getConnection();
+            for (const col of droppable) {
+                const rows = (await conn.execute(`SELECT COUNT(*) AS n FROM ${q(tableName)} WHERE ${q(col)} IS NOT NULL`));
+                const n = rows[0]?.n ?? 0;
+                if (n > 0) {
+                    log.warn(`schema sync is about to DROP ${tableName}.${col} — it still holds ${n} row(s) of data. Add a migration (TableOps.convert/renameColumn/changeType) before the next start, or the data is lost.`);
+                }
+            }
+        }
+    }
+    catch (e) {
+        log.error('drop-warning check failed (diagnostic only, sync continues)', e);
+    }
+}
 export async function syncSchema() {
+    await warnAboutColumnsToBeDropped();
     await getOrm().schema.update({ safe: false, dropTables: false });
 }

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>;