@coffer-org/server 3.3.0 → 3.4.0

package/dist/part-injection.js

@@ -1,93 +1,392 @@
 import { isField, isGroup, isCollectionGroup } from '@coffer-org/sdk/fields';
-async function partValue(p, ctx, self) {
-    return typeof p.value === 'function' ? await p.value({ ...ctx, self }) : p.value;
+import { mandatedClientParts } from '@coffer-org/sdk/parts';
+import { PartContractError } from "./part-errors.js";
+import { createRefLoader } from "./part-ref.js";
+export const newPartMemo = () => new Map();
+class NeedsCompletion extends Error {
+    scope;
+    key;
+    constructor(scope, key) {
+        super(`needs completion: ${key}`);
+        this.scope = scope;
+        this.key = key;
+    }
 }
-async function completeOne(key, fm, value, ctx) {
-    if (value == null || typeof value !== 'object' || Array.isArray(value))
-        return value;
-    const self = { ...value };
-    for (const p of fm.parts) {
-        if (p.mode !== 'pinned' && p.mode !== 'computed')
-            continue;
-        try {
-            self[p.role] = await partValue(p, ctx, self);
+let scopeUid = 0;
+async function partValue(p, ctx) {
+    return typeof p.value === 'function' ? await p.value(ctx) : p.value;
+}
+function rethrowLoud(e) {
+    if (e instanceof PartContractError || e instanceof NeedsCompletion)
+        throw e;
+}
+function isComputeUnit(fm) {
+    return Boolean(fm.parts?.length) || (fm.virtual === true && fm.compute !== undefined);
+}
+const unitsCache = new WeakMap();
+function scopeUnits(fields) {
+    const cached = unitsCache.get(fields);
+    if (cached)
+        return cached;
+    const out = new Map();
+    const scan = (list) => {
+        for (const it of list) {
+            if (isField(it)) {
+                if (isComputeUnit(it.type))
+                    out.set(it.key, it.type);
+            }
+            else if (isGroup(it) && !it.key)
+                scan(it.fields);
         }
-        catch (e) {
-            console.warn(`[part-injection] '${key}.${p.role}' threw`, e);
+    };
+    scan(fields);
+    unitsCache.set(fields, out);
+    return out;
+}
+const embeddedCache = new WeakMap();
+function scopeEmbedded(fields) {
+    const cached = embeddedCache.get(fields);
+    if (cached)
+        return cached;
+    const out = new Map();
+    const scan = (list) => {
+        for (const it of list) {
+            if (!isGroup(it))
+                continue;
+            if (!it.key)
+                scan(it.fields);
+            else if (!isCollectionGroup(it))
+                out.set(it.key, it.fields);
+        }
+    };
+    scan(fields);
+    embeddedCache.set(fields, out);
+    return out;
+}
+const relationsCache = new WeakMap();
+function levelRelations(fields) {
+    const cached = relationsCache.get(fields);
+    if (cached)
+        return cached;
+    const out = new Map();
+    const scan = (list) => {
+        for (const it of list) {
+            if (isField(it)) {
+                if (it.type.relation)
+                    out.set(it.key, it.type);
+            }
+            else if (isGroup(it) && !it.key)
+                scan(it.fields);
         }
+    };
+    scan(fields);
+    relationsCache.set(fields, out);
+    return out;
+}
+function childScope(scope, key) {
+    const existing = scope.groups.get(key);
+    if (existing)
+        return existing;
+    const sub = scope.embedded.get(key);
+    if (!sub)
+        return null;
+    const cur = scope.obj[key];
+    if (!isPlainObject(cur))
+        return null;
+    const copy = { ...cur };
+    scope.obj[key] = copy;
+    const child = newScope(scope.st, copy, sub, `${scope.path}${key}.`, scope.level, scope.level.label);
+    scope.groups.set(key, child);
+    return child;
+}
+function makeProxy(scope) {
+    return new Proxy(scope.obj, {
+        get(target, prop, receiver) {
+            if (typeof prop === 'string') {
+                if (scope.units.has(prop) && scope.status.get(prop) !== 'done')
+                    throw new NeedsCompletion(scope, prop);
+                const child = childScope(scope, prop);
+                if (child)
+                    return child.proxy;
+            }
+            return Reflect.get(target, prop, receiver);
+        },
+    });
+}
+function newScope(st, obj, fields, path, level, label) {
+    const scope = {
+        st,
+        uid: ++scopeUid,
+        obj,
+        units: scopeUnits(fields),
+        embedded: scopeEmbedded(fields),
+        status: new Map(),
+        inflight: new Map(),
+        path,
+        level: level,
+        proxy: null,
+        groups: new Map(),
+    };
+    scope.proxy = makeProxy(scope);
+    if (!level)
+        scope.level = { fields, scope, proxy: scope.proxy, label };
+    return scope;
+}
+function refsOf(st) {
+    if (!st.refs) {
+        st.refs = {
+            chain: st.selfKey ? [st.selfKey] : [],
+            loader: createRefLoader((m, record, refs) => injectParts(m.fields, record, {
+                settings: {},
+                global: {},
+                meta: { library: m.library, shelf: m.shelf },
+                ...(st.ctx.em ? { em: st.ctx.em } : {}),
+                refs,
+            }), st.ctx.em),
+        };
     }
-    return self;
+    return st.refs;
+}
+function siteOf(field, role) {
+    return role ? `'${field}.${role}'` : `'${field}'`;
+}
+function refFor(scope, key, field, role) {
+    const level = scope.level;
+    const fm = levelRelations(level.fields).get(key);
+    if (!fm?.relation) {
+        const known = [...levelRelations(level.fields).keys()];
+        throw new PartContractError(`ctx.ref('${key}') in ${scope.st.ctx.meta.library}/${scope.st.ctx.meta.shelf} ${siteOf(field, role)}: ` +
+            `'${key}' is not a relation field of ${level.label} ` +
+            `(relation fields there: ${known.length ? known.map((k) => `'${k}'`).join(', ') : 'none'}). ` +
+            `ctx.ref takes the KEY of a relation declared next to this field, not a path.`);
+    }
+    if (fm.hints?.['multi'] === true || fm.hints?.['multiple'] === true) {
+        throw new PartContractError(`ctx.ref('${key}') in ${scope.st.ctx.meta.library}/${scope.st.ctx.meta.shelf} ${siteOf(field, role)}: ` +
+            `'${key}' is a MULTIPLE relation — ctx.ref resolves one record, not a list.`);
+    }
+    const raw = level.scope.obj[key];
+    if (raw == null || raw === '')
+        return Promise.resolve(null);
+    const id = typeof raw === 'number' ? raw : Number(raw);
+    if (!Number.isInteger(id))
+        return Promise.resolve(null);
+    const refs = refsOf(scope.st);
+    return refs.loader.load(fm.relation.library, fm.relation.shelf, id, refs.chain);
 }
-async function computeOne(key, fm, value, ctx) {
+function storedRefError(scope, key, field, role) {
+    const { library, shelf } = scope.st.ctx.meta;
+    return new PartContractError(`ctx.ref('${key}') in ${library}/${shelf} ${siteOf(field, role)}: a computed-AND-STORED part must not read ` +
+        `another record. Its column is written once, at write time, and nothing recomputes it when the record it ` +
+        `read changes — the value would be stale and look authoritative. Drop the part's 'key' so the value is ` +
+        `computed on every read instead.`);
+}
+function computeCtxFor(scope, self, stored, field, role) {
+    const st = scope.st;
+    return {
+        record: st.recordLevel.proxy,
+        parent: scope.level.proxy,
+        settings: st.ctx.settings,
+        global: st.ctx.global,
+        meta: st.ctx.meta,
+        self,
+        ref: stored
+            ? (key) => {
+                throw storedRefError(scope, key, field, role);
+            }
+            : (key) => refFor(scope, key, field, role),
+    };
+}
+async function completeValue(scope, key, fm, value, idx) {
     if (value == null || typeof value !== 'object' || Array.isArray(value))
         return value;
+    const st = scope.st;
+    const write = st.mode === 'write';
     const self = { ...value };
+    const scopeId = `${st.ctx.meta.library}/${st.ctx.meta.shelf}`;
+    const path = idx === undefined ? `${scopeId}|${scope.path}${key}` : `${scopeId}|${scope.path}${key}.${idx}`;
     const contextOnly = [];
     for (const p of fm.parts) {
         if (p.mode !== 'pinned' && p.mode !== 'computed')
             continue;
-        contextOnly.push(p.role);
+        if (write)
+            contextOnly.push(p.role);
+        const memoKey = `${path}|${p.role}`;
+        if (st.memo.has(memoKey)) {
+            self[p.role] = st.memo.get(memoKey);
+            continue;
+        }
         try {
-            self[p.role] = await partValue(p, ctx, self);
+            const v = await partValue(p, computeCtxFor(scope, self, false, key, p.role));
+            self[p.role] = v;
+            st.memo.set(memoKey, v);
         }
         catch (e) {
-            console.warn(`[part-compute] '${key}.${p.role}' threw`, e);
+            rethrowLoud(e);
+            console.warn(`[${write ? 'part-compute' : 'part-injection'}] '${key}.${p.role}' threw`, e);
         }
     }
-    for (const p of fm.parts) {
-        if (p.mode !== 'computedStored')
-            continue;
-        try {
-            self[p.key] = await partValue(p, ctx, self);
-        }
-        catch (e) {
-            console.warn(`[part-compute] '${key}.${p.role}' threw`, e);
+    if (write) {
+        for (const p of fm.parts) {
+            if (p.mode !== 'computedStored')
+                continue;
+            try {
+                self[p.key] = await partValue(p, computeCtxFor(scope, self, true, key, p.role));
+            }
+            catch (e) {
+                rethrowLoud(e);
+                console.warn(`[part-compute] '${key}.${p.role}' threw`, e);
+            }
         }
+        if (contextOnly.length)
+            st.strip.push({ value: self, roles: contextOnly });
     }
-    for (const role of contextOnly)
-        delete self[role];
     return self;
 }
-async function walkFields(fields, obj, ctx, complete) {
-    const out = { ...obj };
+function materializable(fm) {
+    const parts = fm.parts ?? [];
+    if (!parts.some((p) => p.mode === 'computedStored'))
+        return false;
+    if (mandatedClientParts(fm.required, parts).length > 0)
+        return false;
+    return true;
+}
+function storedFilled(fm, value) {
+    if (value == null || typeof value !== 'object')
+        return false;
+    const v = value;
+    return (fm.parts ?? []).some((p) => p.key && v[p.key] != null && v[p.key] !== '');
+}
+function isPlainObject(v) {
+    return v != null && typeof v === 'object' && !Array.isArray(v);
+}
+async function runVirtualField(scope, key, fm) {
+    if (scope.st.mode === 'write') {
+        delete scope.obj[key];
+        return;
+    }
+    try {
+        scope.obj[key] = await partValue({ value: fm.compute }, computeCtxFor(scope, {}, false, key, ''));
+    }
+    catch (e) {
+        rethrowLoud(e);
+        console.warn(`[part-injection] '${key}' threw`, e);
+    }
+}
+async function runFieldUnit(scope, key, fm) {
+    if (fm.virtual === true && fm.compute !== undefined)
+        return runVirtualField(scope, key, fm);
+    if (!fm.parts?.length)
+        return;
+    const value = scope.obj[key];
+    if (value == null) {
+        if (scope.st.mode !== 'write' || fm.hints?.['multiple'] === true || !materializable(fm))
+            return;
+        const made = await completeValue(scope, key, fm, {}, undefined);
+        if (storedFilled(fm, made))
+            scope.obj[key] = made;
+        return;
+    }
+    if (fm.hints?.['multiple'] === true) {
+        if (!Array.isArray(value))
+            return;
+        const out = [];
+        for (const [i, v] of value.entries())
+            out.push(await completeValue(scope, key, fm, v, i));
+        scope.obj[key] = out;
+        return;
+    }
+    scope.obj[key] = await completeValue(scope, key, fm, value, undefined);
+}
+async function completeUnit(scope, key, chain) {
+    if (scope.status.get(key) === 'done')
+        return;
+    const fm = scope.units.get(key);
+    if (!fm)
+        return;
+    const hop = `${scope.uid}:${key}`;
+    const repeat = chain.indexOf(hop);
+    if (repeat !== -1) {
+        const names = [...chain.slice(repeat), hop].map((h) => `'${h.slice(h.indexOf(':') + 1)}'`);
+        throw new PartContractError(`[part-injection] ${scope.st.ctx.meta.library}/${scope.st.ctx.meta.shelf}: completion cycle ${names.join(' → ')}` +
+            ` — these composite parts read each other, so neither can be completed first.`);
+    }
+    const inflight = scope.inflight.get(key);
+    if (inflight)
+        return inflight;
+    const next = [...chain, hop];
+    const run = (async () => {
+        const resolved = new Set();
+        for (;;) {
+            try {
+                await runFieldUnit(scope, key, fm);
+                break;
+            }
+            catch (e) {
+                if (!(e instanceof NeedsCompletion))
+                    throw e;
+                const dep = `${e.scope.uid}:${e.key}`;
+                if (resolved.has(dep))
+                    throw new PartContractError(`[part-injection] ${scope.st.ctx.meta.library}/${scope.st.ctx.meta.shelf}: '${key}' demands '${e.key}' ` +
+                        `again after it was completed — its compute function cannot make progress (a stale suspension held ` +
+                        `across invocations, or a value object read outside the context it was handed).`);
+                resolved.add(dep);
+                await completeUnit(e.scope, e.key, next);
+            }
+        }
+        scope.status.set(key, 'done');
+    })();
+    scope.inflight.set(key, run);
+    try {
+        await run;
+    }
+    finally {
+        scope.inflight.delete(key);
+    }
+}
+async function driveScope(scope, fields) {
     for (const it of fields) {
         if (isField(it)) {
-            const fm = it.type;
-            if (!fm.parts?.length)
-                continue;
-            const value = out[it.key];
-            if (value == null)
+            if (!isComputeUnit(it.type))
                 continue;
-            if (fm.hints?.['multiple'] === true) {
-                if (!Array.isArray(value))
-                    continue;
-                out[it.key] = await Promise.all(value.map((v) => complete(it.key, fm, v, ctx)));
-            }
-            else {
-                out[it.key] = await complete(it.key, fm, value, ctx);
-            }
+            await completeUnit(scope, it.key, []);
         }
         else if (isGroup(it)) {
+            const sub = it.fields;
             if (!it.key) {
-                Object.assign(out, await walkFields(it.fields, out, ctx, complete));
+                await driveScope(scope, sub);
             }
             else if (isCollectionGroup(it)) {
-                const rows = out[it.key];
-                if (Array.isArray(rows)) {
-                    out[it.key] = await Promise.all(rows.map((row) => row != null && typeof row === 'object'
-                        ? walkFields(it.fields, row, ctx, complete)
-                        : row));
-                }
+                const rows = scope.obj[it.key];
+                if (!Array.isArray(rows))
+                    continue;
+                const copies = rows.map((row) => (isPlainObject(row) ? { ...row } : row));
+                scope.obj[it.key] = copies;
+                await Promise.all(copies.map((row, i) => isPlainObject(row)
+                    ? runScope(scope.st, row, sub, `${scope.path}${it.key}.${i}.`, null, `collection row '${it.key}'`)
+                    : Promise.resolve(row)));
             }
             else {
-                const sub = out[it.key];
-                if (sub != null && typeof sub === 'object' && !Array.isArray(sub)) {
-                    out[it.key] = await walkFields(it.fields, sub, ctx, complete);
+                const cur = scope.obj[it.key];
+                const child = childScope(scope, it.key);
+                if (child) {
+                    await driveScope(child, sub);
+                }
+                else if (cur == null && scope.st.mode === 'write' && partWork(sub).computedStored) {
+                    const made = newScope(scope.st, {}, sub, `${scope.path}${it.key}.`, scope.level, scope.level.label);
+                    await driveScope(made, sub);
+                    if (Object.keys(made.obj).length) {
+                        scope.obj[it.key] = made.obj;
+                        scope.groups.set(it.key, made);
+                    }
                 }
             }
         }
     }
-    return out;
+}
+async function runScope(st, obj, fields, path, level, label) {
+    const scope = newScope(st, obj, fields, path, level, label);
+    await driveScope(scope, fields);
+    return scope.obj;
 }
 const partWorkCache = new WeakMap();
 function partWork(fields) {
@@ -97,6 +396,8 @@ function partWork(fields) {
     const found = { unstored: false, computedStored: false };
     for (const it of fields) {
         if (isField(it)) {
+            if (it.type.virtual === true && it.type.compute !== undefined)
+                found.unstored = true;
             for (const p of it.type.parts ?? []) {
                 if (p.mode === 'pinned' || p.mode === 'computed')
                     found.unstored = true;
@@ -113,13 +414,35 @@ function partWork(fields) {
     partWorkCache.set(fields, found);
     return found;
 }
+async function runWalk(fields, row, ctx, mode) {
+    const id = row['id'] ?? row['base_id'];
+    const st = {
+        ctx,
+        mode,
+        memo: ctx.memo ?? newPartMemo(),
+        refs: ctx.refs ?? null,
+        strip: [],
+        selfKey: typeof id === 'number' ? `${ctx.meta.library}/${ctx.meta.shelf}#${id}` : null,
+        recordLevel: null,
+    };
+    const scope = newScope(st, { ...row }, fields, '', null, `${ctx.meta.library}/${ctx.meta.shelf}`);
+    st.recordLevel = scope.level;
+    await driveScope(scope, fields);
+    for (const s of st.strip)
+        for (const role of s.roles)
+            delete s.value[role];
+    return scope.obj;
+}
 export async function injectParts(fields, row, ctx) {
     if (!partWork(fields).unstored)
         return row;
-    return walkFields(fields, row, ctx, completeOne);
+    return runWalk(fields, row, ctx, 'read');
+}
+export function hasStoredPartWork(fields) {
+    return partWork(fields).computedStored;
 }
 export async function applyStoredParts(fields, row, ctx) {
     if (!partWork(fields).computedStored)
         return row;
-    return walkFields(fields, row, ctx, computeOne);
+    return runWalk(fields, row, ctx, 'write');
 }

package/dist/part-ref.d.ts

@@ -0,0 +1,13 @@
+import type { EntityManager } from '@mikro-orm/core';
+import type { ShelfDef } from '@coffer-org/sdk/shelf';
+type Row = Record<string, unknown>;
+export type CompleteRef = (m: ShelfDef, record: Row, refs: RefState) => Promise<Row>;
+export interface RefLoader {
+    load(library: string, shelf: string, id: number, chain: readonly string[]): Promise<Row | null>;
+}
+export interface RefState {
+    loader: RefLoader;
+    chain: readonly string[];
+}
+export declare function createRefLoader(complete: CompleteRef, em?: EntityManager): RefLoader;
+export {};

package/dist/part-ref.js

@@ -0,0 +1,109 @@
+import { getEm } from "./db.js";
+import { selectRows } from "./read-rows.js";
+import { nestEmbedded, readAtMany } from "./collection-io.js";
+import { decodeTemporal } from "./temporal.js";
+import { shelfTableName } from "./entity-schema.js";
+import { getShelf } from "./registry-context.js";
+import { chunk } from "./batch.js";
+import { PartContractError } from "./part-errors.js";
+const MAX_REF_DEPTH = 8;
+export function createRefLoader(complete, em) {
+    const cache = new Map();
+    const waiters = new Map();
+    const pending = new Map();
+    let scheduled = false;
+    const loader = { load };
+    function load(library, shelf, id, chain) {
+        const key = `${library}/${shelf}#${id}`;
+        if (chain.includes(key)) {
+            console.warn(`[part-ref] ref loop ${[...chain, key].join(' → ')} — resolved as null. Two records reach each other ` +
+                `through ctx.ref; the value at the far end of the loop cannot be computed.`);
+            return Promise.resolve(null);
+        }
+        if (chain.length >= MAX_REF_DEPTH) {
+            console.warn(`[part-ref] ref chain deeper than ${MAX_REF_DEPTH} hops (${[...chain, key].join(' → ')}) — resolved as null.`);
+            return Promise.resolve(null);
+        }
+        const hit = cache.get(key);
+        if (hit)
+            return hit;
+        const p = new Promise((resolve, reject) => {
+            waiters.set(key, { resolve, reject, chain: [...chain, key] });
+        });
+        p.catch(() => { });
+        cache.set(key, p);
+        const shelfKey = `${library}/${shelf}`;
+        const ids = pending.get(shelfKey);
+        if (ids)
+            ids.push(id);
+        else
+            pending.set(shelfKey, [id]);
+        if (!scheduled) {
+            scheduled = true;
+            queueMicrotask(flush);
+        }
+        return p;
+    }
+    function flush() {
+        scheduled = false;
+        const batches = [...pending];
+        pending.clear();
+        for (const [shelfKey, ids] of batches)
+            void runBatch(shelfKey, ids);
+    }
+    function settle(key, fn) {
+        const w = waiters.get(key);
+        if (!w)
+            return;
+        waiters.delete(key);
+        fn(w);
+    }
+    async function runBatch(shelfKey, ids) {
+        const slash = shelfKey.indexOf('/');
+        const library = shelfKey.slice(0, slash);
+        const shelf = shelfKey.slice(slash + 1);
+        const keyOf = (id) => `${shelfKey}#${id}`;
+        const unique = [...new Set(ids)];
+        try {
+            const m = getShelf(library, shelf);
+            if (!m)
+                throw new PartContractError(`ctx.ref: no shelf '${shelfKey}' in the registry`);
+            const fork = em ?? getEm().fork();
+            const table = shelfTableName(library, shelf);
+            const flats = [];
+            for (const part of chunk(unique)) {
+                flats.push(...(await selectRows(fork, table, { id: { $in: part }, deleted_at: null })));
+            }
+            const foundIds = flats.map((r) => Number(r['id']));
+            const collectionsById = await readAtMany(fork, table, m.fields, foundIds);
+            const seen = new Set();
+            await Promise.all(flats.map(async (flat) => {
+                const id = Number(flat['id']);
+                seen.add(id);
+                const key = keyOf(id);
+                const w = waiters.get(key);
+                if (!w)
+                    return;
+                const record = {
+                    ...nestEmbedded(m, decodeTemporal(m, flat)),
+                    ...(collectionsById.get(id) ?? {}),
+                };
+                try {
+                    const done = await complete(m, record, { loader, chain: w.chain });
+                    settle(key, (x) => x.resolve(done));
+                }
+                catch (e) {
+                    settle(key, (x) => x.reject(e));
+                }
+            }));
+            for (const id of unique)
+                if (!seen.has(id))
+                    settle(keyOf(id), (w) => w.resolve(null));
+        }
+        catch (e) {
+            for (const id of unique)
+                settle(keyOf(id), (w) => w.reject(e));
+        }
+    }
+    return loader;
+}

package/dist/plugin-runtime.js

@@ -185,6 +185,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/recompute-derived.js

@@ -1,4 +1,6 @@
+import { collectionGroups } from '@coffer-org/sdk/shelf';
 import { derivedEntries, applyDerived } from '@coffer-org/sdk/derive';
+import { applyStoredParts, hasStoredPartWork } from "./part-injection.js";
 import { getEm } from "./db.js";
 import { selectRows } from "./read-rows.js";
 import { encodeJson } from "./mutate.js";
@@ -11,8 +13,23 @@ function sameValue(a, b) {
         return false;
     return a === b;
 }
+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));
+    const out = {};
+    for (const [k, v] of Object.entries(after)) {
+        if (collKeys.has(k))
+            continue;
+        if (JSON.stringify(before[k] ?? null) !== JSON.stringify(v ?? null))
+            out[k] = v;
+    }
+    return out;
+}
 export async function recomputeDerivedFields(m, entityName) {
-    if (derivedEntries(m.fields).length === 0)
+    const storedParts = hasStoredPartWork(m.fields);
+    if (derivedEntries(m.fields).length === 0 && !storedParts)
         return { scanned: 0, changed: 0 };
     const fork = getEm().fork();
     const rows = await selectRows(fork, entityName, {}, { orderBy: { id: 'asc' } });
@@ -22,10 +39,13 @@ export async function recomputeDerivedFields(m, entityName) {
         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)
+        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, derived)));
+        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))