@agentshouse/mdruntime 0.1.0-alpha.9 → 0.1.0-c30ed2b8e04d5

package/dist/save.js

@@ -1,350 +1,259 @@
-import { apply, links, parse, serialize } from '@agentshouse/mdmodel';
-import { immutable } from './change.js';
-import { governing, parseCollection, typesAt, validateCollection } from './collection.js';
+import { definitionOf } from './model.js';
+import { apply, links, parse, retarget, serialize, target, } from '@agentshouse/mdmodel';
+import { immutable, } from './change.js';
+import { governing, parseCollection, validateCollection, } from './collection.js';
 import { changeBatchIdentity } from './identity.js';
 import { overlay } from './overlay.js';
-import { beneath, covered, normalize, relative, resolve } from './paths.js';
+import { covered, normalize, relative } from './paths.js';
 function refuse(rule, file, location) {
     return {
         kind: 'refused',
         refusal: {
             rule,
-            ...file === undefined ? {} : {
-                file
-            },
-            ...location === undefined ? {} : {
-                location
-            }
-        }
-    };
-}
-function members(visible, prefix) {
-    return [
-        ...Object.keys(visible.documents),
-        ...visible.binaryTargets
-    ].filter((path)=>beneath(prefix, path)).sort();
-}
-function spread(change, path, member) {
-    if (change.kind === 'remove') return {
-        kind: 'remove',
-        path: member
-    };
-    return {
-        kind: 'move',
-        path: member,
-        to: `${change.to}${member.slice(path.length)}`
-    };
-}
-function expand(changes, visible) {
-    const expanded = [];
-    for (const change of changes){
-        if (change.kind !== 'move' && change.kind !== 'remove') {
-            expanded.push(change);
-            continue;
-        }
-        const path = normalize(change.path);
-        const to = change.kind === 'move' ? normalize(change.to) : '';
-        if (path === null || path === '' || to === null || change.kind === 'move' && to === '') {
-            return {
-                kind: 'refused',
-                refusal: {
-                    rule: 'room-root',
-                    file: change.path
-                }
-            };
-        }
-        const structural = change.kind === 'move' ? {
-            ...change,
-            path,
-            to
-        } : {
-            ...change,
-            path
-        };
-        const present = visible.documents[path] !== undefined || visible.binaryTargets.includes(path);
-        if (present) {
-            expanded.push(structural);
-            continue;
-        }
-        const beneathIt = members(visible, path);
-        if (beneathIt.length === 0) {
-            return {
-                kind: 'refused',
-                refusal: {
-                    rule: 'path-absent',
-                    file: change.path
-                }
-            };
-        }
-        for (const member of beneathIt)expanded.push(spread(structural, path, member));
-    }
-    return {
-        kind: 'changes',
-        changes: expanded
+            ...(file === undefined ? {} : { file }),
+            ...(location === undefined ? {} : { location }),
+        },
     };
 }
 function referenceField(spec) {
-    if (typeof spec !== 'object' || spec === null) return false;
-    const declared = spec;
-    return declared.kind === 'reference' || declared.kind === 'list' && declared.of === 'reference';
+    return spec.kind === 'reference' || (spec.kind === 'list' && spec.of.kind === 'reference');
 }
-function definitionOf(types, type) {
-    return types.find((declared)=>declared.name === type);
-}
-function retarget(value, from, to, moves) {
+function repointed(value, from, to, moves) {
     if (Array.isArray(value)) {
-        const next = value.map((item)=>retarget(item, from, to, moves) ?? item);
-        return next.some((item, index)=>item !== value[index]) ? next : undefined;
+        const next = value.map((item) => repointed(item, from, to, moves) ?? item);
+        return next.some((item, index) => item !== value[index]) ? next : undefined;
     }
-    if (typeof value !== 'string') return undefined;
-    const target = resolve(from, value);
-    if (target === null) return undefined;
-    const next = relative(to, moves.get(target) ?? target);
-    return next === value ? undefined : next;
+    if (typeof value !== 'string')
+        return undefined;
+    const named = target(from, value);
+    if (named === null)
+        return undefined;
+    const destination = moves.get(named) ?? named;
+    return target(to, value) === destination ? undefined : retarget(value, relative(to, destination));
 }
 function edited(document, path, changes) {
     let next = document;
-    for (const change of changes){
-        if (change.path !== path) continue;
-        if (change.kind !== 'section' && change.kind !== 'preamble') continue;
-        const applied = apply(next, change.kind === 'preamble' ? {
-            kind: 'preamble',
-            value: change.value,
-            prior: next.preamble
-        } : {
-            kind: 'section',
-            name: change.name,
-            value: change.value,
-            prior: next.sections[change.name]
-        });
-        if (applied.outcome === 'applied') next = applied.document;
+    for (const change of changes) {
+        if (change.path !== path)
+            continue;
+        if (change.kind !== 'section' && change.kind !== 'preamble')
+            continue;
+        const applied = apply(next, change.kind === 'preamble'
+            ? { kind: 'preamble', value: change.value, prior: next.preamble }
+            : {
+                kind: 'section',
+                name: change.name,
+                value: change.value,
+                prior: next.sections[change.name],
+            });
+        if (applied.outcome === 'applied')
+            next = applied.document;
     }
     return next;
 }
 function bodies(path, before, after) {
     const changes = [];
     if (after.preamble !== before.preamble) {
-        changes.push({
-            kind: 'preamble',
-            path,
-            value: after.preamble
-        });
+        changes.push({ kind: 'preamble', path, value: after.preamble });
     }
-    for (const [name, value] of Object.entries(after.sections)){
-        if (before.sections[name] === value) continue;
-        changes.push({
-            kind: 'section',
-            path,
-            name,
-            value
-        });
+    for (const [name, value] of Object.entries(after.sections)) {
+        if (before.sections[name] === value)
+            continue;
+        changes.push({ kind: 'section', path, name, value });
     }
     return changes;
 }
 function relinks(path, moved, before, moves) {
     let after = before;
-    for (const link of links(before, path)){
+    for (const link of links(before, path)) {
         const destination = moves.get(link.target) ?? link.target;
-        if (destination === link.target && moved === path) continue;
+        if (destination === link.target && moved === path)
+            continue;
         const to = relative(moved, destination);
-        if (to === relative(path, link.target)) continue;
-        const applied = apply(after, {
-            kind: 'link',
-            href: link.href,
-            to
-        });
+        if (to === relative(path, link.target))
+            continue;
+        const applied = apply(after, { kind: 'link', href: link.href, to });
         if (applied.outcome === 'refuse') {
             return {
                 kind: 'refused',
                 refusal: {
                     rule: applied.refusal.rule,
                     file: path,
-                    ...applied.refusal.location === undefined ? {} : {
-                        location: applied.refusal.location
-                    }
-                }
+                    ...(applied.refusal.location === undefined ? {} : { location: applied.refusal.location }),
+                },
             };
         }
         after = applied.document;
     }
-    if (after === before) return {
-        kind: 'changes',
-        changes: []
-    };
+    if (after === before)
+        return { kind: 'changes', changes: [] };
     if (before.type === undefined) {
-        return {
-            kind: 'changes',
-            changes: [
-                {
-                    kind: 'replace',
-                    path,
-                    content: serialize(after)
-                }
-            ]
-        };
+        return { kind: 'changes', changes: [{ kind: 'replace', path, content: serialize(after) }] };
     }
-    return {
-        kind: 'changes',
-        changes: bodies(path, before, after)
-    };
+    return { kind: 'changes', changes: bodies(path, before, after) };
 }
 function subsumed(merged, path) {
-    for(let index = merged.length - 1; index >= 0; index -= 1){
+    for (let index = merged.length - 1; index >= 0; index -= 1) {
         const item = merged[index];
-        if (item.path !== path) continue;
-        if (item.kind === 'section' || item.kind === 'preamble') merged.splice(index, 1);
+        if (item.path !== path)
+            continue;
+        if (item.kind === 'section' || item.kind === 'preamble')
+            merged.splice(index, 1);
     }
 }
 function rewrites(changes, visible) {
     const moves = new Map();
     const settled = new Set();
-    for (const change of changes){
-        if (change.kind === 'move') moves.set(change.path, change.to);
+    for (const change of changes) {
+        if (change.kind === 'move')
+            moves.set(change.path, change.to);
         if (change.kind === 'remove' || change.kind === 'replace' || change.kind === 'create') {
             settled.add(change.path);
         }
-        if (change.kind === 'field') settled.add(`${change.path} ${change.name}`);
+        if (change.kind === 'field')
+            settled.add(`${change.path} ${change.name}`);
     }
-    if (moves.size === 0) return {
-        kind: 'changes',
-        changes
-    };
-    const merged = [
-        ...changes
-    ];
+    if (moves.size === 0)
+        return { kind: 'changes', changes };
+    const merged = [...changes];
     const added = [];
-    for (const [path, document] of Object.entries(visible.collection.documents)){
-        if (settled.has(path)) continue;
+    for (const [path, document] of Object.entries(visible.collection.documents)) {
+        if (settled.has(path))
+            continue;
         const moved = moves.get(path) ?? path;
-        const definition = definitionOf(typesAt(visible.collection.composition, path), document.type);
-        for (const [name, spec] of Object.entries(definition?.fields ?? {})){
-            if (!referenceField(spec) || settled.has(`${path} ${name}`)) continue;
-            const value = retarget(document.fields[name], path, moved, moves);
-            if (value === undefined) continue;
-            added.push({
-                kind: 'field',
-                path,
-                name,
-                value
-            });
+        const definition = definitionOf(governing(visible.collection.composition, path), document.type);
+        for (const [name, spec] of Object.entries(definition?.fields ?? {})) {
+            if (!referenceField(spec) || settled.has(`${path} ${name}`))
+                continue;
+            const value = repointed(document.fields[name], path, moved, moves);
+            if (value === undefined)
+                continue;
+            added.push({ kind: 'field', path, name, value });
         }
         const relinked = relinks(path, moved, edited(document, path, merged), moves);
-        if (relinked.kind === 'refused') return relinked;
-        for (const change of relinked.changes){
+        if (relinked.kind === 'refused')
+            return relinked;
+        for (const change of relinked.changes) {
             if (change.kind === 'replace') {
                 subsumed(merged, path);
                 added.push(change);
                 continue;
             }
-            const index = merged.findIndex((item)=>item.kind === change.kind && item.path === path && (change.kind !== 'section' || item.kind === 'section' && item.name === change.name));
-            if (index === -1) added.push(change);
-            else merged[index] = change;
+            const index = merged.findIndex((item) => item.kind === change.kind &&
+                item.path === path &&
+                (change.kind !== 'section' || (item.kind === 'section' && item.name === change.name)));
+            if (index === -1)
+                added.push(change);
+            else
+                merged[index] = change;
         }
     }
+    return { kind: 'changes', changes: [...added, ...merged] };
+}
+function anticipated(changes, preconditions, rewritten, visible) {
+    const derived = rewritten.filter((change) => !changes.includes(change));
+    return {
+        changes: rewritten,
+        preconditions: [...preconditionsOf(derived, visible, []), ...preconditions],
+    };
+}
+export function providerRewritten(batch, visible) {
+    const rewritten = rewrites(batch.changes, visible);
+    if (rewritten.kind === 'refused')
+        return batch;
     return {
-        kind: 'changes',
-        changes: [
-            ...added,
-            ...merged
-        ]
+        ...batch,
+        ...anticipated(batch.changes, batch.preconditions, rewritten.changes, visible),
     };
 }
 function targets(value, from) {
-    const values = Array.isArray(value) ? value : [
-        value
-    ];
+    const values = Array.isArray(value) ? value : [value];
     const resolved = [];
-    for (const item of values){
-        if (typeof item !== 'string') continue;
-        const target = resolve(from, item);
-        if (target !== null) resolved.push(target);
+    for (const item of values) {
+        if (typeof item !== 'string')
+            continue;
+        const named = target(from, item);
+        if (named !== null)
+            resolved.push(named);
     }
     return resolved;
 }
 function incoming(collection, removed) {
     const found = new Map();
-    const note = (target, file)=>{
-        if (!removed.has(target)) return;
+    const note = (target, file) => {
+        if (!removed.has(target))
+            return;
         const referrers = found.get(target) ?? new Set();
         referrers.add(file);
         found.set(target, referrers);
     };
-    for (const [path, document] of Object.entries(collection.documents)){
-        const definition = definitionOf(typesAt(collection.composition, path), document.type);
-        for (const [name, spec] of Object.entries(definition?.fields ?? {})){
-            if (!referenceField(spec)) continue;
-            for (const target of targets(document.fields[name], path))note(target, path);
+    for (const [path, document] of Object.entries(collection.documents)) {
+        const definition = definitionOf(governing(collection.composition, path), document.type);
+        for (const [name, spec] of Object.entries(definition?.fields ?? {})) {
+            if (!referenceField(spec))
+                continue;
+            for (const named of targets(document.fields[name], path))
+                note(named, path);
         }
-        for (const link of links(document, path))note(link.target, path);
+        for (const link of links(document, path))
+            note(link.target, path);
     }
-    const [first] = [
-        ...found.keys()
-    ].sort();
-    if (first === undefined) return null;
+    const [first] = [...found.keys()].sort();
+    if (first === undefined)
+        return null;
     const every = new Set();
-    for (const referrers of found.values())for (const file of referrers)every.add(file);
+    for (const referrers of found.values())
+        for (const file of referrers)
+            every.add(file);
     return {
         kind: 'refused',
-        refusal: {
-            rule: 'referenced-missing-file',
-            file: first,
-            referrers: [
-                ...every
-            ].sort()
-        }
+        refusal: { rule: 'referenced-missing-file', file: first, referrers: [...every].sort() },
     };
 }
 function affected(change) {
-    return change.kind === 'move' ? [
-        change.path,
-        change.to
-    ] : [
-        change.path
-    ];
-}
-function definitionAddresses(composition) {
-    const addresses = new Set();
-    if (composition.model.status !== 'unavailable') {
-        for (const path of Object.keys(composition.model.snapshot.definitions))addresses.add(path);
-    }
-    if (composition.selection !== null && composition.selection.model.status !== 'unavailable') {
-        for (const path of Object.keys(composition.selection.model.snapshot.definitions)){
-            addresses.add(path);
-        }
-    }
-    return addresses;
+    return change.kind === 'move' ? [change.path, change.to] : [change.path];
 }
 function guard(changes, input) {
     const existing = new Set([
         ...Object.keys(input.visible.documents),
-        ...input.visible.binaryTargets
+        ...input.visible.binaryTargets,
     ]);
-    const definitions = definitionAddresses(input.composition);
-    for (const change of changes){
-        for (const path of affected(change)){
+    for (const change of changes) {
+        for (const path of affected(change)) {
             const normalized = normalize(path);
-            if (normalized === null || normalized === '') return refuse('room-root', path);
-            if (definitions.has(normalized)) return refuse('model-definition', normalized);
+            if (normalized === null || normalized === '')
+                return refuse('room-root', path);
             if (covered(input.providerOwnedPaths, normalized)) {
                 return refuse('provider-owned-path', normalized);
             }
             const operation = change.kind === 'remove' ? 'delete' : 'write';
-            if (!covered(input.operations[operation], normalized)) return refuse(`${operation}-grant`, normalized);
+            if (!covered(input.operations[operation], normalized))
+                return refuse(`${operation}-grant`, normalized);
         }
         if (change.kind === 'create') {
-            if (existing.has(change.path)) return refuse('path-collision', change.path);
+            if (existing.has(change.path))
+                return refuse('path-collision', change.path);
             existing.add(change.path);
             continue;
         }
         if (change.kind === 'move') {
-            if (!existing.has(change.path)) return refuse('path-absent', change.path);
-            if (existing.has(change.to)) return refuse('path-collision', change.to);
+            if (!existing.has(change.path))
+                return refuse('path-absent', change.path);
+            if (existing.has(change.to))
+                return refuse('path-collision', change.to);
+            if (unrevisionedDocument(input.visible, change.path)) {
+                return refuse('unknown-revision', change.path);
+            }
             existing.delete(change.path);
             existing.add(change.to);
             continue;
         }
-        if (!existing.has(change.path)) return refuse('path-absent', change.path);
+        if (!existing.has(change.path))
+            return refuse('path-absent', change.path);
         if (change.kind === 'remove') {
+            if (unrevisionedDocument(input.visible, change.path)) {
+                return refuse('unknown-revision', change.path);
+            }
             existing.delete(change.path);
             continue;
         }
@@ -354,77 +263,71 @@ function guard(changes, input) {
             }
             continue;
         }
-        const document = input.visible.collection.documents[change.path];
-        if (document === undefined) return refuse('path-absent', change.path);
-        if (change.kind === 'section' && document.sections[change.name] === undefined) {
-            return refuse('required-section', change.path, change.name);
+        if (input.visible.collection.documents[change.path] === undefined) {
+            return refuse('path-absent', change.path);
         }
     }
     return null;
 }
+function unrevisionedDocument(visible, path) {
+    return visible.revisions[path] === undefined && !visible.binaryTargets.includes(path);
+}
 function existence(visible, path) {
     const revision = visible.revisions[path];
-    return revision === undefined ? {
-        kind: 'present',
-        path
-    } : {
-        kind: 'revision',
-        path,
-        revision
-    };
+    return revision === undefined ? { kind: 'present', path } : { kind: 'revision', path, revision };
+}
+function sameTarget(precondition, change) {
+    if (precondition.kind !== change.kind || precondition.path !== change.path)
+        return false;
+    return ((precondition.kind !== 'field' && precondition.kind !== 'section') ||
+        ((change.kind === 'field' || change.kind === 'section') && precondition.name === change.name));
 }
-function preconditionsOf(changes, visible) {
+function preconditionsOf(changes, visible, bases) {
     const preconditions = [];
     const seen = new Set();
-    const add = (precondition)=>{
+    const add = (precondition) => {
         const part = precondition.kind === 'field' || precondition.kind === 'section' ? precondition.name : '';
         const identity = `${precondition.kind} ${precondition.path} ${part}`;
-        if (seen.has(identity)) return;
+        if (seen.has(identity))
+            return;
         seen.add(identity);
         preconditions.push(precondition);
     };
-    for (const change of changes){
-        if (change.kind === 'field') {
-            const document = visible.collection.documents[change.path];
-            add({
-                kind: 'field',
-                path: change.path,
-                name: change.name,
-                value: document.fields[change.name]
-            });
-            continue;
-        }
-        if (change.kind === 'section') {
-            const document = visible.collection.documents[change.path];
-            add({
-                kind: 'section',
-                path: change.path,
-                name: change.name,
-                value: document.sections[change.name]
-            });
-            continue;
-        }
-        if (change.kind === 'preamble') {
+    for (const change of changes) {
+        if (change.kind === 'field' || change.kind === 'section' || change.kind === 'preamble') {
+            const based = bases.find((base) => sameTarget(base, change));
+            if (based !== undefined) {
+                add(based);
+                continue;
+            }
             const document = visible.collection.documents[change.path];
-            add({
-                kind: 'preamble',
-                path: change.path,
-                value: document.preamble
-            });
+            if (change.kind === 'field') {
+                add({
+                    kind: 'field',
+                    path: change.path,
+                    name: change.name,
+                    value: document.fields[change.name],
+                });
+            }
+            else if (change.kind === 'section') {
+                add({
+                    kind: 'section',
+                    path: change.path,
+                    name: change.name,
+                    value: document.sections[change.name],
+                });
+            }
+            else
+                add({ kind: 'preamble', path: change.path, value: document.preamble });
             continue;
         }
         if (change.kind === 'create') {
-            add({
-                kind: 'absent',
-                path: change.path
-            });
+            add({ kind: 'absent', path: change.path });
             continue;
         }
         add(existence(visible, change.path));
-        if (change.kind === 'move') add({
-            kind: 'absent',
-            path: change.to
-        });
+        if (change.kind === 'move')
+            add({ kind: 'absent', path: change.to });
     }
     return preconditions;
 }
@@ -432,90 +335,98 @@ function depth(path) {
     return path.split('/').length;
 }
 function exceeded(limits, changes, resulting) {
-    const written = changes.map((change)=>change.kind === 'move' ? change.to : change.path);
-    const created = changes.filter((change)=>change.kind === 'create' || change.kind === 'move').map((change)=>change.kind === 'move' ? change.to : change.path);
-    for (const limit of limits){
+    const written = changes.map((change) => (change.kind === 'move' ? change.to : change.path));
+    const created = changes
+        .filter((change) => change.kind === 'create' || change.kind === 'move')
+        .map((change) => (change.kind === 'move' ? change.to : change.path));
+    for (const limit of limits) {
         const value = limit.value;
-        if (typeof value !== 'number') continue;
+        if (typeof value !== 'number')
+            continue;
         if (limit.name === 'change-batch-operations' && changes.length > value) {
             return refuse('provider-limit', undefined, limit.name);
         }
+        if (limit.name === 'change-documents' &&
+            new Set(changes.map((change) => change.path)).size > value) {
+            return refuse('provider-limit', undefined, limit.name);
+        }
         if (limit.name === 'document-size') {
-            const large = written.find((path)=>(resulting.documents[path] ?? '').length > value);
-            if (large !== undefined) return refuse('provider-limit', large, limit.name);
+            const large = written.find((path) => (resulting.documents[path] ?? '').length > value);
+            if (large !== undefined)
+                return refuse('provider-limit', large, limit.name);
         }
         if (limit.name === 'path-length') {
-            const long = created.find((path)=>path.length > value);
-            if (long !== undefined) return refuse('provider-limit', long, limit.name);
+            const long = created.find((path) => path.length > value);
+            if (long !== undefined)
+                return refuse('provider-limit', long, limit.name);
         }
         if (limit.name === 'path-depth') {
-            const deep = created.find((path)=>depth(path) > value);
-            if (deep !== undefined) return refuse('provider-limit', deep, limit.name);
+            const deep = created.find((path) => depth(path) > value);
+            if (deep !== undefined)
+                return refuse('provider-limit', deep, limit.name);
         }
     }
     return null;
 }
 export function buildBatch(input) {
-    const structural = input.changes.find((change)=>change.kind === 'move' || change.kind === 'remove');
-    if (structural !== undefined && Object.entries(input.visible.collection.documents).some(([path, document])=>document.type !== undefined && document.type !== 'any' && governing(input.composition, path).status === 'unavailable')) return refuse('model-unavailable', structural.path);
-    const expanded = expand(input.changes, input.visible);
-    if (expanded.kind === 'refused') return expanded;
-    const rewritten = rewrites(expanded.changes, input.visible);
-    if (rewritten.kind === 'refused') return rewritten;
-    const changes = rewritten.changes;
-    if (changes.length === 0) return refuse('no-change');
+    const structural = input.changes.find((change) => change.kind === 'move' || change.kind === 'remove');
+    if (structural !== undefined &&
+        Object.entries(input.visible.collection.documents).some(([path, document]) => document.type !== undefined &&
+            document.type !== 'any' &&
+            governing(input.composition, path).status === 'unavailable'))
+        return refuse('model-unavailable', structural.path);
+    if (input.changes.length === 0)
+        return refuse('no-change');
+    const rewritten = rewrites(input.changes, input.visible);
+    if (rewritten.kind === 'refused')
+        return rewritten;
+    const changes = input.changes;
     const refusal = guard(changes, input);
-    if (refusal !== null) return refusal;
-    const preconditions = preconditionsOf(changes, input.visible);
+    if (refusal !== null)
+        return refusal;
+    const preconditions = preconditionsOf(changes, input.visible, input.bases);
+    const predicted = anticipated(changes, preconditions, rewritten.changes, input.visible);
     const resulting = overlay(input.visible, [
-        {
-            id: '',
-            baseRoomVersion: input.baseRoomVersion,
-            changes,
-            preconditions
-        }
+        { id: '', baseRoomVersion: input.baseRoomVersion, ...predicted },
     ]);
-    const removed = new Set(changes.filter((change)=>change.kind === 'remove').map((change)=>change.path));
+    const removed = new Set(changes.filter((change) => change.kind === 'remove').map((change) => change.path));
     if (removed.size > 0) {
         const referenced = incoming(parseCollection(resulting.documents, input.composition), removed);
-        if (referenced !== null) return referenced;
+        if (referenced !== null)
+            return referenced;
     }
-    const typed = (content)=>{
-        if (content === undefined) return false;
+    const typed = (content) => {
+        if (content === undefined)
+            return false;
         const parsed = parse(content);
         return parsed.ok && parsed.document.type !== undefined && parsed.document.type !== 'any';
     };
-    const typedPaths = [
-        ...new Set(changes.flatMap(affected))
-    ].filter((path)=>typed(input.visible.documents[path]) || typed(resulting.documents[path]));
+    const typedPaths = [...new Set(predicted.changes.flatMap(affected))].filter((path) => typed(input.visible.documents[path]) || typed(resulting.documents[path]));
     const needsModel = typedPaths.length > 0;
-    const withoutModel = typedPaths.find((path)=>governing(input.composition, path).status === 'unavailable');
-    if (needsModel && (withoutModel !== undefined || input.binding === null)) {
-        return refuse('model-unavailable', withoutModel ?? typedPaths[0]);
-    }
-    const validationText = needsModel ? resulting.documents : Object.fromEntries(Object.entries(resulting.documents).filter(([path])=>changes.some((change)=>affected(change).includes(path))));
-    const verdict = validateCollection(validationText, resulting.binaryTargets, input.composition, input.binding);
+    const withoutModel = typedPaths.find((path) => governing(input.composition, path).status === 'unavailable');
+    if (withoutModel !== undefined)
+        return refuse('model-unavailable', withoutModel);
+    const validationText = needsModel
+        ? resulting.documents
+        : Object.fromEntries(Object.entries(resulting.documents).filter(([path]) => predicted.changes.some((change) => affected(change).includes(path))));
+    const verdict = validateCollection(validationText, resulting.binaryTargets, input.composition);
     if (verdict.verdict === 'refuse') {
         return {
             kind: 'refused',
             refusal: {
-                ...verdict.source === 'model' ? {
-                    source: 'model'
-                } : {},
                 rule: verdict.rule,
                 file: verdict.file,
-                ...verdict.location === undefined ? {} : {
-                    location: verdict.location
-                },
-                ...verdict.referrers === undefined ? {} : {
-                    referrers: verdict.referrers
-                }
-            }
+                ...(verdict.location === undefined ? {} : { location: verdict.location }),
+                ...(verdict.referrers === undefined ? {} : { referrers: verdict.referrers }),
+            },
         };
     }
     const limited = exceeded(input.providerLimits, changes, resulting);
-    if (limited !== null) return limited;
-    const validated = typedPaths.map((path)=>governing(input.composition, path)).find((model)=>model.status !== 'unavailable');
+    if (limited !== null)
+        return limited;
+    const validated = typedPaths
+        .map((path) => governing(input.composition, path))
+        .find((model) => model.status !== 'unavailable');
     return {
         kind: 'batch',
         batch: immutable({
@@ -523,15 +434,16 @@ export function buildBatch(input) {
             baseRoomVersion: input.baseRoomVersion,
             changes,
             preconditions,
-            ...validated === undefined ? {} : {
-                validation: {
-                    identity: validated.snapshot.identity,
-                    version: validated.snapshot.version,
-                    source: validated.status
-                }
-            }
-        })
+            ...(input.writtenBy === undefined ? {} : { writtenBy: input.writtenBy }),
+            ...(validated === undefined
+                ? {}
+                : {
+                    validation: {
+                        identity: validated.snapshot.identity,
+                        version: validated.snapshot.version,
+                        source: validated.status,
+                    },
+                }),
+        }),
     };
 }
-
-//# sourceMappingURL=save.js.map