@coffer-org/server 3.4.0 → 5.0.0

package/dist/compute-unit.d.ts

@@ -0,0 +1,66 @@
+import { type FieldMeta, type FieldView, type ContainerNode, type LayoutEl } from '@coffer-org/sdk/fields';
+import { PartContractError } from './part-errors.ts';
+import { type RefState } from './part-ref.ts';
+import type { PartCtx, PartMemo } from './part-injection.ts';
+export type Row = Record<string, unknown>;
+export interface PartComputeCtx {
+    record: Row;
+    parent: Row;
+    settings: Record<string, unknown>;
+    global: Record<string, unknown>;
+    meta: {
+        library: string;
+        shelf: string;
+    };
+    self: Row;
+    ref(key: string): Promise<Row | null>;
+    now: string;
+    fields(path: string | (string | number)[]): FieldView | null;
+    path: (string | number)[];
+}
+export interface Level {
+    fields: LayoutEl[];
+    scope: Scope;
+    proxy: Row;
+    label: string;
+}
+export interface Scope {
+    st: WalkState;
+    uid: number;
+    obj: Row;
+    units: Map<string, FieldMeta | ContainerNode>;
+    embedded: Map<string, LayoutEl[]>;
+    status: Map<string, 'done'>;
+    proxy: Row;
+    groups: Map<string, Scope>;
+    path: readonly (string | number)[];
+    level: Level;
+}
+export interface WalkState {
+    ctx: PartCtx;
+    mode: 'read' | 'write';
+    memo: PartMemo;
+    refs: RefState | null;
+    selfKey: string | null;
+    recordLevel: Level;
+    now: string;
+}
+export declare function partValue(p: {
+    value?: unknown;
+}, ctx: PartComputeCtx): Promise<unknown>;
+export declare function rethrowLoud(e: unknown): void;
+export declare function isComputeUnit(fm: FieldMeta): boolean;
+export declare function scopeUnits(fields: LayoutEl[]): Map<string, FieldMeta | ContainerNode>;
+export declare function scopeEmbedded(fields: LayoutEl[]): Map<string, LayoutEl[]>;
+export declare function levelRelations(fields: LayoutEl[]): Map<string, FieldMeta>;
+export declare function childScope(scope: Scope, key: string, create?: boolean): Scope | null;
+export declare function newScope(st: WalkState, obj: Row, fields: LayoutEl[], path: readonly (string | number)[], level: Level | null, label: string): Scope;
+export declare function refFor(scope: Scope, key: string, field: string, role: string): Promise<Row | null>;
+export declare function storedRefError(scope: Scope, key: string, field: string, role: string): PartContractError;
+export declare function computeCtxFor(scope: Scope, self: Row, cache: number | undefined, field: string, role: string): PartComputeCtx;
+export declare function completeValue(scope: Scope, key: string, fm: FieldMeta, value: unknown): Promise<unknown>;
+export declare function materializable(fm: FieldMeta): boolean;
+export declare function storedFilled(fm: FieldMeta, value: unknown): boolean;
+export declare function isPlainObject(v: unknown): boolean;
+export declare function isGroupUnit(fm: FieldMeta | ContainerNode): fm is ContainerNode;
+export declare function runFieldUnit(scope: Scope, key: string, fm: FieldMeta | ContainerNode): Promise<void>;

package/dist/compute-unit.js

@@ -0,0 +1,369 @@
+import { hasChildren, isNamedField, isCollectionGroup, isEmbeddedGroup, isStorageGroup, } from '@coffer-org/sdk/fields';
+import { mandatedClientParts } from '@coffer-org/sdk/parts';
+import { PartContractError } from "./part-errors.js";
+import { createRefLoader } from "./part-ref.js";
+import { wholeClockColumn, partClockColumn } from "./cache-clock.js";
+let scopeUid = 0;
+export async function partValue(p, ctx) {
+    return typeof p.value === 'function' ? await p.value(ctx) : p.value;
+}
+export function rethrowLoud(e) {
+    if (e instanceof PartContractError)
+        throw e;
+}
+export function isComputeUnit(fm) {
+    return Boolean(fm.parts?.length) || fm.compute !== undefined;
+}
+const unitsCache = new WeakMap();
+export 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 (isNamedField(it)) {
+                if (isComputeUnit(it.type))
+                    out.set(it.key, it.type);
+            }
+            else if (hasChildren(it)) {
+                if (isStorageGroup(it) && it.compute !== undefined)
+                    out.set(it.key, it);
+                else if (!isStorageGroup(it))
+                    scan(it.fields);
+            }
+        }
+    };
+    scan(fields);
+    unitsCache.set(fields, out);
+    return out;
+}
+const embeddedCache = new WeakMap();
+export 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 (!hasChildren(it))
+                continue;
+            if (!isStorageGroup(it))
+                scan(it.fields);
+            else if (isEmbeddedGroup(it))
+                out.set(it.key, it.fields);
+        }
+    };
+    scan(fields);
+    embeddedCache.set(fields, out);
+    return out;
+}
+const relationsCache = new WeakMap();
+export 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 (isNamedField(it)) {
+                if (it.type.relation)
+                    out.set(it.key, it.type);
+            }
+            else if (hasChildren(it) && it.scope === 'hoist')
+                scan(it.fields);
+        }
+    };
+    scan(fields);
+    relationsCache.set(fields, out);
+    return out;
+}
+export function childScope(scope, key, create = false) {
+    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) && !create)
+        return null;
+    const copy = isPlainObject(cur) ? { ...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;
+}
+export function newScope(st, obj, fields, path, level, label) {
+    const scope = {
+        st,
+        uid: ++scopeUid,
+        obj,
+        units: scopeUnits(fields),
+        embedded: scopeEmbedded(fields),
+        status: new Map(),
+        path,
+        level: level,
+        proxy: obj,
+        groups: new Map(),
+    };
+    if (!level)
+        scope.level = { fields, scope, proxy: obj, label };
+    return scope;
+}
+function refsOf(st) {
+    if (!st.refs) {
+        st.refs = {
+            chain: st.selfKey ? [st.selfKey] : [],
+            loader: createRefLoader((_m, record) => Promise.resolve(record), st.ctx.em),
+        };
+    }
+    return st.refs;
+}
+function siteOf(field, role) {
+    return role ? `'${field}.${role}'` : `'${field}'`;
+}
+export 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);
+}
+export function storedRefError(scope, key, field, role) {
+    const { library, shelf } = scope.st.ctx.meta;
+    const noun = role ? 'part' : 'field';
+    return new PartContractError(`ctx.ref('${key}') in ${library}/${shelf} ${siteOf(field, role)}: a computed-AND-STORED ${noun} must not read ` +
+        `another record unless it declares \`cache\`. 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. Declare ` +
+        `\`cache\` on the ${noun} to allow a refreshed cross-record read.`);
+}
+function resolveField(levelObj, fields, path, i) {
+    if (i >= path.length)
+        return null;
+    const seg = path[i];
+    for (const el of fields) {
+        if (isNamedField(el)) {
+            if (typeof seg !== 'string' || el.key !== seg)
+                continue;
+            const fm = el.type;
+            if (i === path.length - 1) {
+                const cacheKey = fm.cache !== undefined ? wholeClockColumn(el.key) : null;
+                return { value: levelObj[el.key], kind: fm.kind, cacheKey, owner: levelObj };
+            }
+            const partSeg = path[i + 1];
+            if (i + 2 !== path.length || typeof partSeg !== 'string')
+                return null;
+            const part = fm.parts?.find((p) => p.key === partSeg);
+            if (!part)
+                return null;
+            const composite = levelObj[el.key];
+            const value = isPlainObject(composite) ? composite[partSeg] : undefined;
+            const cacheKey = part.meta.cache !== undefined ? partClockColumn(el.key, partSeg) : null;
+            return { value, kind: part.meta.kind, cacheKey, owner: levelObj };
+        }
+        if (hasChildren(el)) {
+            const sub = el.fields;
+            if (!isStorageGroup(el)) {
+                const found = resolveField(levelObj, sub, path, i);
+                if (found)
+                    return found;
+                continue;
+            }
+            if (typeof seg !== 'string' || el.key !== seg)
+                continue;
+            if (isCollectionGroup(el)) {
+                const idx = path[i + 1];
+                if (typeof idx !== 'number')
+                    return null;
+                const rows = levelObj[el.key];
+                const row = Array.isArray(rows) ? rows[idx] : undefined;
+                if (!isPlainObject(row))
+                    return null;
+                if (i + 2 === path.length)
+                    return { value: row, kind: el.kind ?? 'group', cacheKey: null, owner: levelObj };
+                return resolveField(row, sub, path, i + 2);
+            }
+            if (i === path.length - 1) {
+                return { value: levelObj[el.key], kind: el.kind ?? 'group', cacheKey: null, owner: levelObj };
+            }
+            const child = levelObj[el.key];
+            if (!isPlainObject(child))
+                return null;
+            return resolveField(child, sub, path, i + 1);
+        }
+    }
+    return null;
+}
+function fieldsFor(st, path) {
+    const segs = typeof path === 'string' ? path.split('.') : path;
+    const found = resolveField(st.recordLevel.proxy, st.recordLevel.fields, segs, 0);
+    if (!found)
+        return null;
+    const rawUpdatedAt = st.recordLevel.proxy['updated_at'];
+    const updatedAt = rawUpdatedAt instanceof Date ? rawUpdatedAt.toISOString() : typeof rawUpdatedAt === 'string' ? rawUpdatedAt : null;
+    const rawComputedAt = found.cacheKey != null ? found.owner[found.cacheKey] : undefined;
+    const computedAt = typeof rawComputedAt === 'number' ? rawComputedAt : null;
+    return { value: found.value, kind: found.kind, updatedAt, computedAt };
+}
+export function computeCtxFor(scope, self, cache, 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: cache === undefined
+            ? (key) => {
+                throw storedRefError(scope, key, field, role);
+            }
+            : (key) => refFor(scope, key, field, role),
+        now: st.now,
+        fields: (path) => fieldsFor(st, path),
+        path: role ? [...scope.path, field, role] : [...scope.path, field],
+    };
+}
+export async function completeValue(scope, key, fm, value) {
+    if (value == null || typeof value !== 'object' || Array.isArray(value))
+        return value;
+    const st = scope.st;
+    if (st.mode !== 'write')
+        return value;
+    const self = { ...value };
+    for (const p of fm.parts) {
+        if (p.mode !== 'computedStored')
+            continue;
+        try {
+            self[p.key] = await partValue(p, computeCtxFor(scope, self, p.meta?.cache, key, p.role));
+            if (p.meta?.cache !== undefined)
+                scope.obj[partClockColumn(key, p.key)] = Date.now();
+        }
+        catch (e) {
+            rethrowLoud(e);
+            console.warn(`[part-compute] '${key}.${p.role}' threw`, e);
+        }
+    }
+    return self;
+}
+export 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;
+}
+export function storedFilled(fm, value) {
+    if (value == null || typeof value !== 'object')
+        return false;
+    const v = value;
+    return (fm.parts ?? []).some((p) => v[p.key] != null && v[p.key] !== '');
+}
+export function isPlainObject(v) {
+    return v != null && typeof v === 'object' && !Array.isArray(v);
+}
+export function isGroupUnit(fm) {
+    return hasChildren(fm);
+}
+export async function runFieldUnit(scope, key, fm) {
+    if (isGroupUnit(fm)) {
+        if (scope.st.mode !== 'write')
+            return;
+        let value;
+        try {
+            value = await partValue({ value: fm.compute }, computeCtxFor(scope, {}, undefined, key, ''));
+        }
+        catch (e) {
+            rethrowLoud(e);
+            console.warn(`[part-compute] '${key}' threw`, e);
+            return;
+        }
+        if (isCollectionGroup(fm)) {
+            scope.obj[key] = Array.isArray(value) ? value : [];
+            return;
+        }
+        const child = childScope(scope, key, true);
+        if (value == null) {
+            for (const c of fm.fields)
+                if (isNamedField(c))
+                    child.obj[c.key] = null;
+            return;
+        }
+        if (isPlainObject(value)) {
+            for (const [k, v] of Object.entries(value))
+                child.obj[k] = v;
+        }
+        return;
+    }
+    const wholeFn = fm.compute;
+    if (wholeFn !== undefined && !fm.parts?.length) {
+        if (scope.st.mode !== 'write')
+            return;
+        try {
+            scope.obj[key] = await partValue({ value: wholeFn }, computeCtxFor(scope, {}, fm.cache, key, ''));
+            if (fm.cache !== undefined)
+                scope.obj[wholeClockColumn(key)] = Date.now();
+        }
+        catch (e) {
+            rethrowLoud(e);
+            console.warn(`[part-compute] '${key}' threw`, e);
+        }
+        return;
+    }
+    if (!fm.parts?.length)
+        return;
+    if (wholeFn !== undefined) {
+        if (scope.st.mode !== 'write')
+            return;
+        let value;
+        try {
+            value = await partValue({ value: wholeFn }, computeCtxFor(scope, {}, fm.cache, key, ''));
+            if (fm.cache !== undefined)
+                scope.obj[wholeClockColumn(key)] = Date.now();
+        }
+        catch (e) {
+            rethrowLoud(e);
+            console.warn(`[part-compute] '${key}' threw`, e);
+            return;
+        }
+        scope.obj[key] = value == null ? value : await completeValue(scope, key, fm, value);
+        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, {});
+        if (storedFilled(fm, made))
+            scope.obj[key] = made;
+        return;
+    }
+    if (fm.hints?.['multiple'] === true) {
+        if (!Array.isArray(value))
+            return;
+        const out = [];
+        for (const v of value)
+            out.push(await completeValue(scope, key, fm, v));
+        scope.obj[key] = out;
+        return;
+    }
+    scope.obj[key] = await completeValue(scope, key, fm, value);
+}

package/dist/condition-where.js

@@ -8,7 +8,7 @@ export class ConditionCompileError extends Error {
         this.name = 'ConditionCompileError';
     }
 }
-const coerce = (f, v) => typeof v === 'boolean' ? v : coerceFilter(String(v), f.column);
+const coerce = (f, v) => (typeof v === 'boolean' ? v : coerceFilter(String(v), f.column));
 function memberOperator(pred, key, where) {
     if (typeof pred !== 'object' || pred === null)
         return undefined;
@@ -68,8 +68,6 @@ export function conditionToWhere(m, cond) {
             const f = fm[key];
             if (!f)
                 throw new ConditionCompileError(`${where}: unknown field '${key}'`);
-            if (f.virtual)
-                throw new ConditionCompileError(`${where}: '${key}' is virtual and has no column`);
             const memberOp = memberOperator(spec, key, where);
             if (memberOp && !f.hints['multiple']) {
                 throw new ConditionCompileError(`${where}: '${key}' is not a multiple field — '${memberOp}' does not apply`);

package/dist/data-dir.d.ts

@@ -0,0 +1,3 @@
+export declare function dataDir(): string;
+export declare function instanceDir(...segments: string[]): string;
+export declare function carryInto(dst: string, ...legacyDirs: string[]): void;

package/dist/data-dir.js

@@ -0,0 +1,39 @@
+import { copyFileSync, existsSync, mkdirSync, readdirSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+export function dataDir() {
+    return resolve(process.env.DATA_DIR ?? join(process.cwd(), 'data'));
+}
+export function instanceDir(...segments) {
+    const dir = join(dataDir(), ...segments);
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+export function carryInto(dst, ...legacyDirs) {
+    for (const src of legacyDirs)
+        copyMissing(src, dst);
+}
+function copyMissing(src, dst) {
+    let entries;
+    try {
+        entries = readdirSync(src, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const from = join(src, entry.name);
+        const to = join(dst, entry.name);
+        if (entry.isDirectory()) {
+            copyMissing(from, to);
+            continue;
+        }
+        if (existsSync(to))
+            continue;
+        try {
+            mkdirSync(dst, { recursive: true });
+            copyFileSync(from, to);
+        }
+        catch {
+        }
+    }
+}

package/dist/entity-schema.js

@@ -1,5 +1,7 @@
 import { EntitySchema } from '@mikro-orm/core';
 import { fieldEntries, collectionGroups, storageColumns } from '@coffer-org/sdk/shelf';
+import { cacheClockColumns } from "./cache-clock.js";
+import { SYSTEM_SETTINGS_ID, SYSTEM_SETTINGS } from "./system-settings.js";
 function mikroType(col) {
     if (col === 'integer')
         return 'integer';
@@ -23,8 +25,6 @@ function columnProp(field, nullable) {
 }
 function addFieldProps(properties, fields, plainNullable) {
     for (const [key, field] of fieldEntries(fields)) {
-        if (field.virtual)
-            continue;
         if (field.columns) {
             for (const [col, type] of storageColumns(key, field))
                 properties[col] = { type: mikroType(type), nullable: true };
@@ -33,6 +33,8 @@ function addFieldProps(properties, fields, plainNullable) {
             properties[key] = columnProp(field, plainNullable(field));
         }
     }
+    for (const col of cacheClockColumns(fields))
+        properties[col] = { type: 'integer', nullable: true };
 }
 export function shelfTableName(library, shelf) {
     return `${library}__${shelf}`;
@@ -329,4 +331,5 @@ export const systemEntities = [
     OAuthTokenSchema,
     ThreadMessageSchema,
     ThreadStateSchema,
+    buildSettingsEntitySchema(SYSTEM_SETTINGS_ID, SYSTEM_SETTINGS),
 ];

package/dist/extend-table.d.ts

@@ -3,7 +3,7 @@ import type { ExtendDef } from '@coffer-org/sdk/extend';
 import { type PartMemo } from './part-injection.ts';
 type Row = Record<string, unknown>;
 export declare function extendEntityName(e: ExtendDef): string;
-export declare function getExtendRecord(e: ExtendDef, baseId: number, em?: EntityManager, memo?: PartMemo): Promise<Row | undefined>;
+export declare function getExtendRecord(e: ExtendDef, baseId: number, em?: EntityManager, _memo?: PartMemo): Promise<Row | undefined>;
 export declare function getExtendRecords(e: ExtendDef, baseIds: number[], em?: EntityManager): Promise<Map<number, Row>>;
 export declare function upsertExtendRecord(em: EntityManager, e: ExtendDef, baseId: number, data: Row, memo?: PartMemo): Promise<void>;
 export declare function deleteExtendRecord(em: EntityManager, e: ExtendDef, baseId: number): Promise<void>;

package/dist/extend-table.js

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