@agentshouse/mdruntime 0.1.0-ca9afacd5aebd → 0.1.0-caee7332d2235

package/dist/save.js

@@ -1,10 +1,12 @@
 import { definitionOf } from './model.js';
 import { apply, ATTACHMENT, links, parse, pointerSegments, references, relative, relativize, retarget, serialize, target, } from '@agentshouse/mdmodel';
 import { immutable, queuedFile, departure, } from './change.js';
-import { collectionOf, documentsOf, governing, validateCollection, } from './collection.js';
+import { available, changedCleanly, collectionOf, documentsOf, governing, referring, validateCollection, } from './collection.js';
 import { changeBatchIdentity } from './identity.js';
-import { overlay } from './overlay.js';
+import { overlaying } from './overlay.js';
 import { covered, normalize } from './paths.js';
+import { differences } from './shared.js';
+import { finished, ROW_WEIGHT, stepped } from './turn.js';
 function refuse(code, file, location) {
     return {
         kind: 'refused',
@@ -20,7 +22,7 @@ function repointed(document, definition, from, to, moves, settled) {
     const parsed = parse(document.content, from);
     if (!parsed.ok)
         return [];
-    let next = parsed.document;
+    const changes = [];
     const names = new Set();
     for (const { pointer, value } of definition === undefined
         ? []
@@ -32,38 +34,39 @@ function repointed(document, definition, from, to, moves, settled) {
         const destination = moves.get(named) ?? named;
         if (target(to, value) === destination)
             continue;
-        const applied = apply(next, {
+        changes.push({
             kind: 'reference',
             pointer,
             value: retarget(value, relative(to, destination)),
             prior: value,
         });
-        if (applied.outcome !== 'applied')
-            continue;
-        next = applied.document;
         names.add(name);
     }
+    if (changes.length === 0)
+        return [];
+    const applied = apply(parsed.document, changes);
+    if (applied.outcome !== 'applied')
+        return [];
+    const next = applied.document;
     return [...names].map((name) => ({ kind: 'field', path: from, name, value: next.fields[name] }));
 }
-function edited(document, path, changes) {
-    let next = document;
+function edited(document, changes) {
+    const parts = new Map();
     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 }
-            : {
+        if (change.kind === 'preamble')
+            parts.set('preamble', { kind: 'preamble', value: change.value, prior: document.preamble });
+        if (change.kind === 'section')
+            parts.set(`section ${change.name}`, {
                 kind: 'section',
                 name: change.name,
                 value: change.value,
-                prior: next.sections[change.name],
+                prior: document.sections[change.name] ?? '',
             });
-        if (applied.outcome === 'applied')
-            next = applied.document;
     }
-    return next;
+    if (parts.size === 0)
+        return document;
+    const applied = apply(document, [...parts.values()]);
+    return applied.outcome === 'applied' ? applied.document : document;
 }
 function bodies(path, before, after) {
     const changes = [];
@@ -78,7 +81,7 @@ function bodies(path, before, after) {
     return changes;
 }
 function relinks(path, moved, before, moves) {
-    let after = before;
+    const changes = [];
     for (const link of links(before, path)) {
         const destination = moves.get(link.target) ?? link.target;
         if (destination === link.target && moved === path)
@@ -86,20 +89,23 @@ function relinks(path, moved, before, moves) {
         const to = relative(moved, destination);
         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: {
-                    code: applied.refusal.rule,
-                    retryable: false,
-                    file: path,
-                    ...(applied.refusal.location === undefined ? {} : { location: applied.refusal.location }),
-                },
-            };
-        }
-        after = applied.document;
+        changes.push({ kind: 'link', href: link.href, to });
+    }
+    if (changes.length === 0)
+        return { kind: 'changes', changes: [] };
+    const applied = apply(before, changes);
+    if (applied.outcome === 'refuse') {
+        return {
+            kind: 'refused',
+            refusal: {
+                code: applied.refusal.rule,
+                retryable: false,
+                file: path,
+                ...(applied.refusal.location === undefined ? {} : { location: applied.refusal.location }),
+            },
+        };
     }
+    const after = applied.document;
     if (after === before)
         return { kind: 'changes', changes: [] };
     if (before.type === undefined) {
@@ -107,19 +113,14 @@ function relinks(path, moved, before, moves) {
     }
     return { kind: 'changes', changes: bodies(path, before, after) };
 }
-function subsumed(merged, path) {
-    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);
-    }
+function partKey(change) {
+    return change.kind === 'section' ? `section ${change.name}` : change.kind;
 }
-function rewrites(changes, visible) {
+function* rewrites(changes, visible) {
     const moves = new Map();
     const settled = new Set();
-    for (const change of changes) {
+    const parts = new Map();
+    for (const [index, change] of changes.entries()) {
         if (change.kind === 'move')
             moves.set(change.path, change.to);
         if (change.kind === 'remove' ||
@@ -130,6 +131,13 @@ function rewrites(changes, visible) {
         }
         if (change.kind === 'field')
             settled.add(`${change.path} ${change.name}`);
+        if (isPart(change)) {
+            const held = parts.get(change.path);
+            if (held === undefined)
+                parts.set(change.path, [index]);
+            else
+                held.push(index);
+        }
     }
     if (moves.size === 0)
         return { kind: 'changes', changes };
@@ -141,43 +149,57 @@ function rewrites(changes, visible) {
         const moved = moves.get(path) ?? path;
         const definition = definitionOf(governing(visible.collection.composition, path), document.type);
         added.push(...repointed(document, definition, path, moved, moves, settled));
-        const relinked = relinks(path, moved, edited(document, path, merged), moves);
+        const own = parts.get(path) ?? [];
+        const relinked = relinks(path, moved, edited(document, own.map((index) => merged[index])), moves);
         if (relinked.kind === 'refused')
             return relinked;
+        const keyed = new Map();
+        for (const index of own) {
+            const key = partKey(merged[index]);
+            if (!keyed.has(key))
+                keyed.set(key, index);
+        }
         for (const change of relinked.changes) {
             if (change.kind === 'replace') {
-                subsumed(merged, path);
+                for (const index of own) {
+                    const kind = merged[index]?.kind;
+                    if (kind === 'section' || kind === 'preamble')
+                        merged[index] = null;
+                }
                 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)
+            const index = keyed.get(partKey(change));
+            if (index === undefined)
                 added.push(change);
             else
                 merged[index] = change;
         }
+        yield ROW_WEIGHT + visible.collection.text[path].length;
     }
-    return { kind: 'changes', changes: [...added, ...merged] };
+    return {
+        kind: 'changes',
+        changes: [...added, ...merged.filter((change) => change !== null)],
+    };
 }
-function anticipated(changes, preconditions, rewritten, visible) {
-    const derived = rewritten.filter((change) => !changes.includes(change));
+function* anticipated(changes, preconditions, rewritten, visible) {
+    const given = new Set(changes);
+    const derived = rewritten.filter((change) => !given.has(change));
     return {
         changes: rewritten,
-        preconditions: [...preconditionsOf(derived, visible, []), ...preconditions],
+        preconditions: [...(yield* preconditionsOf(derived, visible, [])), ...preconditions],
     };
 }
-export function providerRewritten(batch, visible) {
-    const rewritten = rewrites(batch.changes, visible);
+export function* providerRewritten(batch, visible) {
+    const rewritten = yield* rewrites(batch.changes, visible);
     if (rewritten.kind === 'refused')
         return batch;
     return {
         ...batch,
-        ...anticipated(batch.changes, batch.preconditions, rewritten.changes, visible),
+        ...(yield* anticipated(batch.changes, batch.preconditions, rewritten.changes, visible)),
     };
 }
-function incoming(collection, removed) {
+function* incoming(collection, removed, candidates) {
     const found = new Map();
     const note = (target, file) => {
         if (!removed.has(target))
@@ -186,7 +208,14 @@ function incoming(collection, removed) {
         referrers.add(file);
         found.set(target, referrers);
     };
-    for (const [path, document] of documentsOf(collection)) {
+    const read = function* (paths) {
+        for (const path of [...new Set(paths)].sort()) {
+            const document = collection.document(path);
+            if (document !== undefined)
+                yield [path, document];
+        }
+    };
+    for (const [path, document] of candidates === null ? documentsOf(collection) : read(candidates)) {
         const definition = definitionOf(governing(collection.composition, path), document.type);
         for (const { value, to } of definition === undefined ? [] : references(document, definition)) {
             if (to.includes(ATTACHMENT))
@@ -195,6 +224,7 @@ function incoming(collection, removed) {
             if (named !== null)
                 note(named, path);
         }
+        yield ROW_WEIGHT + collection.text[path].length;
     }
     const [first] = [...found.keys()].sort();
     if (first === undefined)
@@ -217,10 +247,13 @@ function affected(change) {
     return change.kind === 'move' ? [change.path, change.to] : [change.path];
 }
 function guard(changes, input) {
-    const existing = new Set([
-        ...Object.keys(input.visible.documents),
-        ...Object.keys(input.visible.binaries),
-    ]);
+    const overridden = new Map();
+    const existing = {
+        has: (path) => overridden.get(path) ??
+            (Object.hasOwn(input.visible.documents, path) || Object.hasOwn(input.visible.binaries, path)),
+        add: (path) => void overridden.set(path, true),
+        delete: (path) => void overridden.set(path, false),
+    };
     for (const [index, change] of changes.entries()) {
         for (const path of affected(change)) {
             const normalized = normalize(path);
@@ -275,7 +308,7 @@ function guard(changes, input) {
             continue;
         }
         if (change.kind === 'replace') {
-            if (!input.local && input.visible.revisions[change.path] === undefined) {
+            if (unrevised(input, change.path)) {
                 return refuse('unknown-revision', change.path);
             }
             continue;
@@ -289,6 +322,22 @@ function guard(changes, input) {
 function unrevised(input, path) {
     return (!input.local && input.queued?.has(path) !== true && input.visible.revisions[path] === undefined);
 }
+export function queuedDocuments(queue) {
+    const paths = new Set();
+    for (const batch of queue) {
+        for (const change of batch.changes) {
+            if (change.kind === 'binary')
+                continue;
+            if (change.kind === 'remove')
+                paths.delete(change.path);
+            else if (change.kind !== 'move')
+                paths.add(change.path);
+            else if (paths.delete(change.path))
+                paths.add(change.to);
+        }
+    }
+    return paths;
+}
 function identity(precondition) {
     const part = precondition.kind === 'field' || precondition.kind === 'section' ? precondition.name : '';
     return `${precondition.kind} ${precondition.path} ${part}`;
@@ -306,7 +355,7 @@ function sameTarget(precondition, change) {
     return ((precondition.kind !== 'field' && precondition.kind !== 'section') ||
         ((change.kind === 'field' || change.kind === 'section') && precondition.name === change.name));
 }
-function preconditionsOf(changes, visible, bases) {
+function* preconditionsOf(changes, visible, bases) {
     const preconditions = [];
     const seen = new Set();
     const add = (precondition) => {
@@ -317,6 +366,7 @@ function preconditionsOf(changes, visible, bases) {
         preconditions.push(precondition);
     };
     for (const change of changes) {
+        yield ROW_WEIGHT;
         if (change.kind === 'field' || change.kind === 'section' || change.kind === 'preamble') {
             const based = bases.find((base) => sameTarget(base, change));
             if (based !== undefined) {
@@ -364,8 +414,8 @@ function preconditionsOf(changes, visible, bases) {
 function depth(path) {
     return path.split('/').length;
 }
-function exceeded(limits, changes, resulting) {
-    const written = changes.map((change) => (change.kind === 'move' ? change.to : change.path));
+function* exceeding(limits, changes, effective, resulting) {
+    const written = effective.map((change) => (change.kind === 'move' ? change.to : change.path));
     const created = changes
         .filter((change) => change.kind === 'create' || change.kind === 'move' || change.kind === 'binary')
         .map((change) => (change.kind === 'move' ? change.to : change.path));
@@ -381,9 +431,13 @@ function exceeded(limits, changes, resulting) {
             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);
+            for (const path of written) {
+                const text = resulting.documents[path] ?? '';
+                if (new TextEncoder().encode(text).byteLength > value) {
+                    return refuse('provider-limit', path, limit.name);
+                }
+                yield ROW_WEIGHT + text.length;
+            }
         }
         if (limit.name === 'path-length') {
             const long = created.find((path) => path.length > value);
@@ -413,7 +467,7 @@ function relativeField(path, name, value, handle, definition) {
         !opened.ok ||
         !JSON.stringify(value ?? null).includes(`/rooms/${handle}/`))
         return value;
-    const held = apply(opened.document, { kind: 'field', name, value, prior: undefined });
+    const held = apply(opened.document, [{ kind: 'field', name, value, prior: undefined }]);
     if (held.outcome !== 'applied')
         return value;
     const result = relativize(held.document, path, handle, definition);
@@ -449,12 +503,15 @@ function relativeChanges(input) {
         return { ...change, fields, sections };
     });
 }
-function unmodeledType(collection, composition) {
+function* unmodeledType(collection, composition) {
+    if (available(composition))
+        return false;
     for (const [path, document] of documentsOf(collection)) {
         if (document.type !== undefined &&
             document.type !== 'any' &&
             governing(composition, path).status === 'unavailable')
             return true;
+        yield ROW_WEIGHT + collection.text[path].length;
     }
     return false;
 }
@@ -467,29 +524,44 @@ function isPart(change) {
 function touched(change) {
     return change.kind === 'move' ? [change.path, change.to] : [change.path];
 }
-function partApplied(content, path, change) {
+function partsApplied(content, path, changes) {
     const parsed = parse(content, path);
     if (!parsed.ok)
         return null;
     const document = parsed.document;
-    const applied = apply(document, change.kind === 'field'
-        ? {
-            kind: 'field',
-            name: change.name,
-            value: change.value,
-            prior: document.fields[change.name],
-        }
-        : change.kind === 'section'
-            ? {
+    const parts = new Map();
+    for (const change of changes) {
+        if (change.kind === 'field')
+            parts.set(`field ${change.name}`, {
+                kind: 'field',
+                name: change.name,
+                value: change.value,
+                prior: document.fields[change.name],
+            });
+        else if (change.kind === 'section')
+            parts.set(`section ${change.name}`, {
                 kind: 'section',
                 name: change.name,
                 value: change.value,
-                prior: document.sections[change.name],
-            }
-            : { kind: 'preamble', value: change.value, prior: document.preamble });
+                prior: document.sections[change.name] ?? '',
+            });
+        else
+            parts.set('preamble', { kind: 'preamble', value: change.value, prior: document.preamble });
+    }
+    const applied = apply(document, [...parts.values()]);
     return applied.outcome === 'applied' ? serialize(applied.document) : null;
 }
-function folded(changes, change, appending) {
+function settledParts(changes, deferred) {
+    for (const [held, parts] of deferred) {
+        const content = partsApplied(held.content, held.path, parts);
+        if (content === null)
+            return held.path;
+        changes[changes.indexOf(held)] = { ...held, content };
+    }
+    deferred.clear();
+    return null;
+}
+function folded(changes, change, appending, deferred) {
     const held = changes.find((item) => item.path === change.path && (item.kind === 'create' || item.kind === 'replace'));
     const whole = held === undefined ? -1 : changes.indexOf(held);
     const occupied = changes.some((item) => !isPart(item) && item !== held && touched(item).includes(change.path));
@@ -510,10 +582,11 @@ function folded(changes, change, appending) {
             return 'appended';
         }
         if ('content' in held) {
-            const content = partApplied(held.content, held.path, change);
-            if (content === null)
-                return 'refused';
-            changes[whole] = { ...held, content };
+            const parts = deferred.get(held);
+            if (parts === undefined)
+                deferred.set(held, [change]);
+            else
+                parts.push(change);
             return 'folded';
         }
         if (change.kind === 'preamble')
@@ -545,16 +618,20 @@ function folded(changes, change, appending) {
     return 'appended';
 }
 function relinked(batch, move, before, after, appending) {
-    const derived = rewrites([move], after);
+    const derived = finished(rewrites([move], after));
     if (derived.kind === 'refused')
         return derived;
     const changes = [...batch.changes];
     const appended = [];
     let changed = false;
+    const deferred = new Map();
     for (const change of derived.changes) {
         if (change === move)
             continue;
-        const outcome = folded(changes, change, appending);
+        const unsettled = isPart(change) ? null : settledParts(changes, deferred);
+        if (unsettled !== null)
+            return unqueueable(unsettled);
+        const outcome = folded(changes, change, appending, deferred);
         if (outcome === 'refused')
             return unqueueable(change.path);
         if (outcome === 'appended')
@@ -562,6 +639,9 @@ function relinked(batch, move, before, after, appending) {
         if (outcome !== 'skipped')
             changed = true;
     }
+    const unsettled = settledParts(changes, deferred);
+    if (unsettled !== null)
+        return unqueueable(unsettled);
     if (!changed)
         return { kind: 'relinked', batch };
     const held = new Set(batch.preconditions.map(identity));
@@ -573,7 +653,7 @@ function relinked(batch, move, before, after, appending) {
             changes,
             preconditions: [
                 ...batch.preconditions,
-                ...preconditionsOf(appended, before, []).filter((precondition) => !held.has(identity(precondition))),
+                ...finished(preconditionsOf(appended, before, [])).filter((precondition) => !held.has(identity(precondition))),
             ],
         }),
     };
@@ -695,10 +775,17 @@ export function joined(queue, owner, extra) {
     if (clash !== undefined)
         return unqueueable(clash);
     const changes = [...owner.changes];
+    const deferred = new Map();
     for (const change of extra.changes) {
-        if (folded(changes, change, true) === 'refused')
+        const unsettled = isPart(change) ? null : settledParts(changes, deferred);
+        if (unsettled !== null)
+            return unqueueable(unsettled);
+        if (folded(changes, change, true, deferred) === 'refused')
             return unqueueable(change.path);
     }
+    const unsettled = settledParts(changes, deferred);
+    if (unsettled !== null)
+        return unqueueable(unsettled);
     const held = new Set(owner.preconditions.map(covering));
     const written = new Set(owner.changes.flatMap((change) => change.kind === 'create' || change.kind === 'replace' ? [change.path] : []));
     const preconditions = [
@@ -718,30 +805,36 @@ export function joined(queue, owner, extra) {
     return { kind: 'joined', batch, queue: queue.map((item) => (item === owner ? batch : item)) };
 }
 export function limitedIn(queue, batch, limits, state) {
-    const limited = exceeded(limits, batch.changes, state(queue.slice(0, queue.indexOf(batch) + 1)));
+    const at = queue.indexOf(batch);
+    const limited = finished(exceeding(limits, batch.changes, finished(providerRewritten(batch, state(queue.slice(0, at)))).changes, state(queue.slice(0, at + 1))));
     return limited?.kind === 'refused' ? limited.refusal : null;
 }
-export function buildBatch(input) {
+function* batching(input) {
     const changes = relativeChanges(input);
     const structural = changes.find((change) => change.kind === 'move' || change.kind === 'remove');
-    if (structural !== undefined && unmodeledType(input.visible.collection, input.composition))
+    if (structural !== undefined &&
+        (yield* unmodeledType(input.visible.collection, input.composition)))
         return refuse('model-unavailable', structural.path);
     if (changes.length === 0)
         return refuse('no-change');
-    const rewritten = rewrites(changes, input.visible);
+    const rewritten = yield* rewrites(changes, input.visible);
     if (rewritten.kind === 'refused')
         return rewritten;
     const refusal = guard(changes, input);
     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, [
+    const preconditions = yield* preconditionsOf(changes, input.visible, input.bases);
+    const predicted = yield* anticipated(changes, preconditions, rewritten.changes, input.visible);
+    const resulting = yield* overlaying(input.visible, [
         { id: '', baseRoomVersion: input.baseRoomVersion, ...predicted },
     ]);
+    const clean = input.clean !== undefined && available(input.composition) ? input.clean : null;
     const removed = new Set(changes.filter((change) => change.kind === 'remove').map((change) => change.path));
     if (removed.size > 0) {
-        const referenced = incoming(collectionOf(resulting.documents, input.composition), removed);
+        const referrers = clean === null ? null : referring(clean, input.composition, removed);
+        const referenced = yield* incoming(collectionOf(resulting.documents, input.composition), removed, clean === null || referrers === null
+            ? null
+            : [...referrers, ...(yield* differences(clean.text, resulting.documents))]);
         if (referenced !== null)
             return referenced;
     }
@@ -751,15 +844,27 @@ export function buildBatch(input) {
         const parsed = parse(content);
         return parsed.ok && parsed.document.type !== undefined && parsed.document.type !== 'any';
     };
-    const typedPaths = [...new Set(predicted.changes.flatMap(affected))].filter((path) => typed(input.visible.documents[path]) || typed(resulting.documents[path]));
+    const touched = [...new Set(predicted.changes.flatMap(affected))];
+    const typedPaths = [];
+    for (const path of touched) {
+        const before = input.visible.documents[path];
+        const after = resulting.documents[path];
+        if (typed(before) || typed(after))
+            typedPaths.push(path);
+        yield ROW_WEIGHT + (before?.length ?? 0) + (after?.length ?? 0);
+    }
     const needsModel = typedPaths.length > 0;
     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, Object.keys(resulting.binaries), input.composition);
+    const verdict = clean !== null &&
+        (yield* changedCleanly({ text: resulting.documents, binaries: resulting.binaries }, clean, input.composition))
+        ? { verdict: 'accept' }
+        : yield* validateCollection(needsModel
+            ? resulting.documents
+            : Object.fromEntries(touched.flatMap((path) => resulting.documents[path] === undefined
+                ? []
+                : [[path, resulting.documents[path]]])), Object.keys(resulting.binaries), input.composition);
     if (verdict.verdict === 'refuse') {
         return {
             kind: 'refused',
@@ -772,7 +877,7 @@ export function buildBatch(input) {
             },
         };
     }
-    const limited = exceeded(input.providerLimits, changes, resulting);
+    const limited = yield* exceeding(input.providerLimits, changes, predicted.changes, resulting);
     if (limited !== null)
         return limited;
     const validated = typedPaths
@@ -798,3 +903,6 @@ export function buildBatch(input) {
         }),
     };
 }
+export function buildBatch(input) {
+    return stepped(batching(input));
+}